1.2.0b1

Released: July 10, 2017

• [feature] [oracle] [postgresql] Added new keywords Sequence.cache and
  Sequence.order to Sequence, to allow rendering
  of the CACHE parameter understood by Oracle and PostgreSQL, and the
  ORDER parameter understood by Oracle. Pull request
  courtesy David Moore.

  This change is also backported to: 1.1.12

• [bug] [sql] Fixed AttributeError which would occur in WithinGroup
  construct during an iteration of the structure.

  This change is also backported to: 1.1.11

  References: #4012

• [bug] [orm] Fixed issue with subquery eagerloading which continues on from
  the series of issues fixed in #2699, #3106,
  #3893 involving that the "subquery" contains the correct
  FROM clause when beginning from a joined inheritance subclass
  and then subquery eager loading onto a relationship from
  the base class, while the query also includes criteria against
  the subclass. The fix in the previous tickets did not accommodate
  for additional subqueryload operations loading more deeply from
  the first level, so the fix has been further generalized.

  This change is also backported to: 1.1.11

  References: #4011

• [bug] [postgresql] Continuing with the fix that correctly handles PostgreSQL
  version string "10devel" released in 1.1.8, an additional regexp
  bump to handle version strings of the form "10beta1". While
  PostgreSQL now offers better ways to get this information, we
  are sticking w/ the regexp at least through 1.1.x for the least
  amount of risk to compatibility w/ older or alternate PostgreSQL
  databases.

  This change is also backported to: 1.1.11

  References: #4005

• [bug] [postgresql] Fixed bug where using ARRAY with a string type that
  features a collation would fail to produce the correct syntax
  within CREATE TABLE.

  This change is also backported to: 1.1.11

  References: #4006

• [bug] [mysql] MySQL 5.7 has introduced permission limiting for the "SHOW VARIABLES"
  command; the MySQL dialect will now handle when SHOW returns no
  row, in particular for the initial fetch of SQL_MODE, and will
  emit a warning that user permissions should be modified to allow the
  row to be present.

  This change is also backported to: 1.1.11

  References: #4007

• [bug] [mssql] Fixed bug where SQL Server transaction isolation must be fetched
  from a different view when using Azure data warehouse, the query
  is now attempted against both views and then a NotImplemented
  is raised unconditionally if failure continues to provide the
  best resiliency against future arbitrary API changes in new
  SQL Server versions.

  This change is also backported to: 1.1.11

  References: #3994

• [bug] [oracle] Support for two-phase transactions has been removed entirely for
  cx_Oracle when version 6.0b1 or later of the DBAPI is in use. The two-
  phase feature historically has never been usable under cx_Oracle 5.x in
  any case, and cx_Oracle 6.x has removed the connection-level "twophase"
  flag upon which this feature relied.

  This change is also backported to: 1.1.11

  References: #3997

• [bug] [mssql] Added a placeholder type mssql.XML to the SQL Server
  dialect, so that a reflected table which includes this type can
  be re-rendered as a CREATE TABLE. The type has no special round-trip
  behavior nor does it currently support additional qualifying
  arguments.

  This change is also backported to: 1.1.11

  References: #3973

• [bug] [orm] Fixed bug where a cascade such as "delete-orphan" (but others as well)
  would fail to locate an object linked to a relationship that itself
  is local to a subclass in an inheritance relationship, thus causing
  the operation to not take place.

  This change is also backported to: 1.1.10

  References: #3986

• [bug] [oracle] Fixed bug in cx_Oracle dialect where version string parsing would
  fail for cx_Oracle version 6.0b1 due to the "b" character. Version
  string parsing is now via a regexp rather than a simple split.

  This change is also backported to: 1.1.10

  References: #3975

• [bug] [schema] An ArgumentError is now raised if a
  ForeignKeyConstraint object is created with a mismatched
  number of "local" and "remote" columns, which otherwise causes the
  internal state of the constraint to be incorrect. Note that this
  also impacts the condition where a dialect's reflection process
  produces a mismatched set of columns for a foreign key constraint.

  This change is also backported to: 1.1.10

  References: #3949

• [bug] [ext] Protected against testing "None" as a class in the case where
  declarative classes are being garbage collected and new
  automap prepare() operations are taking place concurrently, very
  infrequently hitting a weakref that has not been fully acted upon
  after gc.

  This change is also backported to: 1.1.10

  References: #3980

• [bug] [postgresql] Added "autocommit" support for GRANT, REVOKE keywords. Pull request
  courtesy Jacob Hayes.

  This change is also backported to: 1.1.10

• [bug] [mysql] Removed an ancient and unnecessary intercept of the UTC_TIMESTAMP
  MySQL function, which was getting in the way of using it with a
  parameter.

  This change is also backported to: 1.1.10

  References: #3966

• [bug] [mysql] Fixed bug in MySQL dialect regarding rendering of table options in
  conjunction with PARTITION options when rendering CREATE TABLE.
  The PARTITION related options need to follow the table options,
  whereas previously this ordering was not enforced.

  This change is also backported to: 1.1.10

  References: #3961

• [bug] [sql] Fixed regression released in 1.1.5 due to #3859 where
  adjustments to the "right-hand-side" evaluation of an expression
  based on Variant to honor the underlying type's
  "right-hand-side" rules caused the Variant type
  to be inappropriately lost, in those cases when we do want the
  left-hand side type to be transferred directly to the right hand side
  so that bind-level rules can be applied to the expression's argument.

  This change is also backported to: 1.1.9

  References: #3952

• [bug] [postgresql] [sql] Changed the mechanics of ResultProxy to unconditionally
  delay the "autoclose" step until the Connection is done
  with the object; in the case where PostgreSQL ON CONFLICT with
  RETURNING returns no rows, autoclose was occurring in this previously
  non-existent use case, causing the usual autocommit behavior that
  occurs unconditionally upon INSERT/UPDATE/DELETE to fail.

  This change is also backported to: 1.1.9

  References: #3955

• [bug] [ext] Fixed bug in sqlalchemy.ext.mutable where the
  Mutable.as_mutable() method would not track a type that had
  been copied using TypeEngine.copy(). This became more of
  a regression in 1.1 compared to 1.0 because the TypeDecorator
  class is now a subclass of SchemaEventTarget, which among
  other things indicates to the parent Column that the type
  should be copied when the Column is. These copies are
  common when using declarative with mixins or abstract classes.

  This change is also backported to: 1.1.8

  References: #3950

• [bug] [ext] Added support for bound parameters, e.g. those normally set up
  via Query.params(), to the baked.Result.count()
  method. Previously, support for parameters were omitted. Pull request
  courtesy Pat Deegan.

  This change is also backported to: 1.1.8

• [bug] [postgresql] Added support for parsing the PostgreSQL version string for
  a development version like "PostgreSQL 10devel". Pull request
  courtesy Sean McCully.

  This change is also backported to: 1.1.8

• [feature] [orm] An aliased() construct can now be passed to the
  Query.select_entity_from() method. Entities will be pulled
  from the selectable represented by the aliased() construct.
  This allows special options for aliased() such as
  aliased.adapt_on_names to be used in conjunction with
  Query.select_entity_from().

  This change is also backported to: 1.1.7

  References: #3933

• [bug] [engine] Added an exception handler that will warn for the "cause" exception on
  Py2K when the "autorollback" feature of Connection itself
  raises an exception. In Py3K, the two exceptions are naturally reported
  by the interpreter as one occurring during the handling of the other.
  This is continuing with the series of changes for rollback failure
  handling that were last visited as part of #2696 in 1.0.12.

  This change is also backported to: 1.1.7

  References: #3946

• [bug] [orm] Fixed a race condition which could occur under threaded environments
  as a result of the caching added via #3915. An internal
  collection of Column objects could be regenerated on an alias
  object inappropriately, confusing a joined eager loader when it
  attempts to render SQL and collect results and resulting in an
  attribute error. The collection is now generated up front before
  the alias object is cached and shared among threads.

  This change is also backported to: 1.1.7

  References: #3947

• [feature] [orm] Added .autocommit attribute to scoped_session, proxying
  the .autocommit attribute of the underling Session
  currently assigned to the thread. Pull request courtesy
  Ben Fagin.

• [feature] [mysql] Added support for MySQL's ON DUPLICATE KEY UPDATE
  MySQL-specific mysql.dml.Insert object.
  Pull request courtesy Michael Doronin.

  References: #4009

• [bug] [sql] The rules for type coercion between Numeric, Integer,
  and date-related types now include additional logic that will attempt
  to preserve the settings of the incoming type on the "resolved" type.
  Currently the target for this is the asdecimal flag, so that
  a math operation between Numeric or Float and
  Integer will preserve the "asdecimal" flag as well as
  if the type should be the Float subclass.

  References: #4018

• [bug] [mysql] [sql] The result processor for the Float type now unconditionally
  runs values through the float() processor if the dialect
  specifies that it also supports "native decimal" mode. While most
  backends will deliver Python float objects for a floating point
  datatype, the MySQL backends in some cases lack the typing information
  in order to provide this and return Decimal unless the float
  conversion is done.

  References: #4020

• [bug] [sql] Added some extra strictness to the handling of Python "float" values
  passed to SQL statements. A "float" value will be associated with the
  Float datatype and not the Decimal-coercing Numeric
  datatype as was the case before, eliminating a confusing warning
  emitted on SQLite as well as unnecessary coercion to Decimal.

  References: #4017

• [feature] [orm] Added a new feature orm.with_expression() that allows an ad-hoc
  SQL expression to be added to a specific entity in a query at result
  time. This is an alternative to the SQL expression being delivered as
  a separate element in the result tuple.

  References: #3058

• [bug] [orm] An UPDATE emitted as a result of the
  relationship.post_update feature will now integrate with
  the versioning feature to both bump the version id of the row as well
  as assert that the existing version number was matched.

  References: #3496

• [bug] [ext] The AssociationProxy.any(), AssociationProxy.has()
  and AssociationProxy.contains() comparison methods now support
  linkage to an attribute that is itself also an
  AssociationProxy, recursively.

  References: #3769

• [bug] [ext] Implemented in-place mutation operators __ior__, __iand__,
  __ixor__ and __isub__ for mutable.MutableSet
  and __iadd__ for mutable.MutableList so that change
  events are fired off when these mutator methods are used to alter the
  collection.

  References: #3853

• [bug] [declarative] A warning is emitted if the declared_attr.cascading modifier
  is used with a declarative attribute that is itself declared on
  a class that is to be mapped, as opposed to a declarative mixin
  class or __abstract__ class. The declared_attr.cascading
  modifier currently only applies to mixin/abstract classes.

  References: #3847

• [feature] [oracle] The Oracle dialect now inspects unique and check constraints when using
  Inspector.get_unique_constraints(),
  Inspector.get_check_constraints().
  As Oracle does not have unique constraints that are separate from a unique
  Index, a Table that's reflected will still continue
  to not have UniqueConstraint objects associated with it.
  Pull requests courtesy Eloy Felix.

  References: #4003

• [feature] [orm] Added a new style of mapper-level inheritance loading
  "polymorphic selectin". This style of loading
  emits queries for each subclass in an inheritance
  hierarchy subsequent to the load of the base
  object type, using IN to specify the desired
  primary key values.

  References: #3948

• [bug] [orm] Repaired several use cases involving the
  relationship.post_update feature when used in conjunction
  with a column that has an "onupdate" value. When the UPDATE emits,
  the corresponding object attribute is now expired or refreshed so that
  the newly generated "onupdate" value can populate on the object;
  previously the stale value would remain. Additionally, if the target
  attribute is set in Python for the INSERT of the object, the value is
  now re-sent during the UPDATE so that the "onupdate" does not overwrite
  it (note this works just as well for server-generated onupdates).
  Finally, the SessionEvents.refresh_flush() event is now emitted
  for these attributes when refreshed within the flush.

  References: #3471, #3472

• [bug] [orm] Fixed bug where programmatic version_id counter in conjunction with
  joined table inheritance would fail if the version_id counter
  were not actually incremented and no other values on the base table
  were modified, as the UPDATE would have an empty SET clause. Since
  programmatic version_id where version counter is not incremented
  is a documented use case, this specific condition is now detected
  and the UPDATE now sets the version_id value to itself, so that
  concurrency checks still take place.

  References: #3996

• [bug] [declarative] [orm] Fixed bug where using declared_attr on an
  AbstractConcreteBase where a particular return value were some
  non-mapped symbol, including None, would cause the attribute
  to hard-evaluate just once and store the value to the object
  dictionary, not allowing it to invoke for subclasses. This behavior
  is normal when declared_attr is on a mapped class, and
  does not occur on a mixin or abstract class. Since
  AbstractConcreteBase is both "abstract" and actually
  "mapped", a special exception case is made here so that the
  "abstract" behavior takes precedence for declared_attr.

  References: #3848

• [bug] [orm] The versioning feature does not support NULL for the version counter.
  An exception is now raised if the version id is programmatic and
  was set to NULL for an UPDATE. Pull request courtesy Diana Clarke.

  References: #3673

• [bug] [sql] The operator precedence for all comparison operators such as LIKE, IS,
  IN, MATCH, equals, greater than, less than, etc. has all been merged
  into one level, so that expressions which make use of these against
  each other will produce parentheses between them. This suits the
  stated operator precedence of databases like Oracle, MySQL and others
  which place all of these operators as equal precedence, as well as
  PostgreSQL as of 9.5 which has also flattened its operator precedence.

  References: #3999

• [bug] [orm] Removed a very old keyword argument from scoped_session
  called scope. This keyword was never documented and was an
  early attempt at allowing for variable scopes.

  References: #3796

• [bug] [mysql] Added support for views that are unreflectable due to stale
  table definitions, when calling MetaData.reflect(); a warning
  is emitted for the table that cannot respond to DESCRIBE,
  but the operation succeeds.

  References: #3871

• [ext] [feature] Added new flag Session.enable_baked_queries to the
  Session to allow baked queries to be disabled
  session-wide, reducing memory use. Also added new Bakery
  wrapper so that the bakery returned by BakedQuery.bakery
  can be inspected.

• [bug] [orm] Fixed bug where combining a "with_polymorphic" load in conjunction
  with subclass-linked relationships that specify joinedload with
  innerjoin=True, would fail to demote those "innerjoins" to
  "outerjoins" to suit the other polymorphic classes that don't
  support that relationship. This applies to both a single and a
  joined inheritance polymorphic load.

  References: #3988

• [bug] [orm] Added new argument with_for_update to the
  Session.refresh() method. When the Query.with_lockmode()
  method were deprecated in favor of Query.with_for_update(),
  the Session.refresh() method was never updated to reflect
  the new option.

  References: #3991

• [bug] [orm] Fixed bug where a column_property() that is also marked as
  "deferred" would be marked as "expired" during a flush, causing it
  to be loaded along with the unexpiry of regular attributes even
  though this attribute was never accessed.

  References: #3984

• [bug] [sql] Repaired issue where the type of an expression that used
  ColumnOperators.is_() or similar would not be a "boolean" type,
  instead the type would be "nulltype", as well as when using custom
  comparison operators against an untyped expression. This typing can
  impact how the expression behaves in larger contexts as well as
  in result-row-handling.

  References: #3873

• [bug] [ext] Improved the association proxy list collection so that premature
  autoflush against a newly created association object can be prevented
  in the case where list.append() is being used, and a lazy load
  would be invoked when the association proxy accesses the endpoint
  collection. The endpoint collection is now accessed first before
  the creator is invoked to produce the association object.

  References: #3941

• [bug] [sql] Fixed the negation of a Label construct so that the
  inner element is negated correctly, when the not_() modifier
  is applied to the labeled expression.

  References: #3969

• [feature] [orm] Added a new kind of eager loading called "selectin" loading. This
  style of loading is very similar to "subquery" eager loading,
  except that it uses an IN expression given a list of primary key
  values from the loaded parent objects, rather than re-stating the
  original query. This produces a more efficient query that is
  "baked" (e.g. the SQL string is cached) and also works in the
  context of Query.yield_per().

  References: #3944

• [bug] [orm] Fixed bug in subquery eager loading where the "join_depth" parameter
  for self-referential relationships would not be correctly honored,
  loading all available levels deep rather than correctly counting
  the specified number of levels for eager loading.

  References: #3967

• [bug] [orm] Added warnings to the LRU "compiled cache" used by the Mapper
  (and ultimately will be for other ORM-based LRU caches) such that
  when the cache starts hitting its size limits, the application will
  emit a warning that this is a performance-degrading situation that
  may require attention. The LRU caches can reach their size limits
  primarily if an application is making use of an unbounded number
  of Engine objects, which is an antipattern. Otherwise,
  this may suggest an issue that should be brought to the SQLAlchemy
  developer's attention.

• [bug] [postgresql] Fixed bug where the base sqltypes.ARRAY datatype would not
  invoke the bind/result processors of postgresql.ARRAY.

  References: #3964

• [bug] [orm] Fixed bug to improve upon the specificity of loader options that
  take effect subsequent to the lazy load of a related entity, so
  that the loader options will match to an aliased or non-aliased
  entity more specifically if those options include entity information.

  References: #3963

• [feature] [orm] The lazy="select" loader strategy now makes used of the
  BakedQuery query caching system in all cases. This
  removes most overhead of generating a Query object and
  running it into a select() and then string SQL statement from
  the process of lazy-loading related collections and objects. The
  "baked" lazy loader has also been improved such that it can now
  cache in most cases where query load options are used.

  References: #3954

• [bug] [sql] The system by which percent signs in SQL statements are "doubled"
  for escaping purposes has been refined. The "doubling" of percent
  signs mostly associated with the literal_column construct
  as well as operators like ColumnOperators.contains() now
  occurs based on the stated paramstyle of the DBAPI in use; for
  percent-sensitive paramstyles as are common with the PostgreSQL
  and MySQL drivers the doubling will occur, for others like that
  of SQLite it will not. This allows more database-agnostic use
  of the literal_column construct to be possible.

  References: #3740

• [bug] [postgresql] Added support for all possible "fields" identifiers when reflecting the
  PostgreSQL INTERVAL datatype, e.g. "YEAR", "MONTH", "DAY TO
  MINUTE", etc.. In addition, the postgresql.INTERVAL
  datatype itself now includes a new parameter
  postgresql.INTERVAL.fields where these qualifiers can be
  specified; the qualifier is also reflected back into the resulting
  datatype upon reflection / inspection.

  References: #3959

• [bug] [sql] Fixed bug where a column-level CheckConstraint would fail
  to compile the SQL expression using the underlying dialect compiler
  as well as apply proper flags to generate literal values as
  inline, in the case that the sqltext is a Core expression and
  not just a plain string. This was long-ago fixed for table-level
  check constraints in 0.9 as part of #2742, which more commonly
  feature Core SQL expressions as opposed to plain string expressions.

  References: #3957

• [bug] [mssql] The SQL Server dialect now allows for a database and/or owner name
  with a dot inside of it, using brackets explicitly in the string around
  the owner and optionally the database name as well. In addition,
  sending the quoted_name construct for the schema name will
  not split on the dot and will deliver the full string as the "owner".
  quoted_name is also now available from the sqlalchemy.sql
  import space.

  References: #2626

• [feature] [sql] Added a new kind of bindparam() called "expanding". This is
  for use in IN expressions where the list of elements is rendered
  into individual bound parameters at statement execution time, rather
  than at statement compilation time. This allows both a single bound
  parameter name to be linked to an IN expression of multiple elements,
  as well as allows query caching to be used with IN expressions. The
  new feature allows the related features of "select in" loading and
  "polymorphic in" loading to make use of the baked query extension
  to reduce call overhead. This feature should be considered to be
  experimental for 1.2.

  References: #3953

• [bug] [sql] Fixed bug where a SQL-oriented Python-side column default could fail to
  be executed properly upon INSERT in the "pre-execute" codepath, if the
  SQL itself were an untyped expression, such as plain text. The "pre-
  execute" codepath is fairly uncommon however can apply to non-integer
  primary key columns with SQL defaults when RETURNING is not used.

  References: #3923

• [bug] [sql] The expression used for COLLATE as rendered by the column-level
  expression.collate() and ColumnOperators.collate() is now
  quoted as an identifier when the name is case sensitive, e.g. has
  uppercase characters. Note that this does not impact type-level
  collation, which is already quoted.

  References: #3785

• [ext] [feature] [orm] The Query.update() method can now accommodate both
  hybrid attributes as well as composite attributes as a source
  of the key to be placed in the SET clause. For hybrids, an
  additional decorator hybrid_property.update_expression()
  is supplied for which the user supplies a tuple-returning function.

  References: #3229

• [bug] [orm] The attributes.flag_modified() function now raises
  InvalidRequestError if the named attribute key is not
  present within the object, as this is assumed to be present
  in the flush process. To mark an object "dirty" for a flush
  without referring to any specific attribute, the
  attributes.flag_dirty() function may be used.

  References: #3753

• [bug] [ext] The sqlalchemy.ext.hybrid.hybrid_property class now supports
  calling mutators like @setter, @expression etc. multiple times
  across subclasses, and now provides a @getter mutator, so that
  a particular hybrid can be repurposed across subclasses or other
  classes. This now matches the behavior of @property in standard
  Python.

  References: #3911, #3912

• [feature] [mysql] [oracle] [postgresql] [sql] Added support for SQL comments on Table and Column
  objects, via the new Table.comment and
  Column.comment arguments. The comments are included
  as part of DDL on table creation, either inline or via an appropriate
  ALTER statement, and are also reflected back within table reflection,
  as well as via the Inspector. Supported backends currently
  include MySQL, PostgreSQL, and Oracle. Many thanks to Frazer McLean
  for a large amount of effort on this.

  References: #1546

• [engine] [feature] Added native "pessimistic disconnection" handling to the Pool
  object. The new parameter Pool.pre_ping, available from
  the engine as create_engine.pool_pre_ping, applies an
  efficient form of the "pre-ping" recipe featured in the pooling
  documentation, which upon each connection check out, emits a simple
  statement, typically "SELECT 1", to test the connection for liveness.
  If the existing connection is no longer able to respond to commands,
  the connection is transparently recycled, and all other connections
  made prior to the current timestamp are invalidated.

  References: #3919

• [bug] [sql] Fixed bug where the use of an Alias object in a column
  context would raise an argument error when it tried to group itself
  into a parenthesized expression. Using Alias in this way
  is not yet a fully supported API, however it applies to some end-user
  recipes and may have a more prominent role in support of some
  future PostgreSQL features.

  References: #3939

• [bug] [orm] The "evaluate" strategy used by Query.update() and
  Query.delete() can now accommodate a simple
  object comparison from a many-to-one relationship to an instance,
  when the attribute names of the primary key / foreign key columns
  don't match the actual names of the columns. Previously this would
  do a simple name-based match and fail with an AttributeError.

  References: #3366

• [feature] [orm] Added new attribute event AttributeEvents.bulk_replace().
  This event is triggered when a collection is assigned to a
  relationship, before the incoming collection is compared with the
  existing one. This early event allows for conversion of incoming
  non-ORM objects as well. The event is integrated with the
  @validates decorator.

  References: #3896

• [bug] [orm] The @validates decorator now allows the decorated method to receive
  objects from a "bulk collection set" operation that have not yet
  been compared to the existing collection. This allows incoming values
  to be converted to compatible ORM objects as is already allowed
  from an "append" event. Note that this means that the
  @validates method is called for all values during a collection
  assignment, rather than just the ones that are new.

  References: #3896

• [bug] [engine] Fixed bug where in the unusual case of passing a
  Compiled object directly to Connection.execute(),
  the dialect with which the Compiled object were generated
  was not consulted for the paramstyle of the string statement, instead
  assuming it would match the dialect-level paramstyle, causing
  mismatches to occur.

  References: #3938

• [feature] [orm] Added new event handler AttributeEvents.modified() which is
  triggered when the func:.attributes.flag_modified function is
  invoked, which is common when using the sqlalchemy.ext.mutable
  extension module.

  References: #3303

• [bug] [ext] Fixed a bug in the sqlalchemy.ext.serializer extension whereby
  an "annotated" SQL element (as produced by the ORM for many types
  of SQL expressions) could not be reliably serialized. Also bumped
  the default pickle level for the serializer to "HIGHEST_PROTOCOL".

  References: #3918

• [bug] [orm] Fixed bug in single-table inheritance where the select_from()
  argument would not be taken into account when limiting rows
  to a subclass. Previously, only expressions in the
  columns requested would be taken into account.

  References: #3891

• [bug] [orm] When assigning a collection to an attribute mapped by a relationship,
  the previous collection is no longer mutated. Previously, the old
  collection would be emptied out in conjunction with the "item remove"
  events that fire off; the events now fire off without affecting
  the old collection.

  References: #3913

• [bug] [oracle] The cx_Oracle dialect now supports "sane multi rowcount", that is,
  when a series of parameter sets are executed via DBAPI
  cursor.executemany(), we can make use of cursor.rowcount to
  verify the number of rows matched. This has an impact within the
  ORM when detecting concurrent modification scenarios, in that
  some simple conditions can now be detected even when the ORM
  is batching statements, as well as when the more strict versioning
  feature is used, the ORM can still use statement batching. The
  flag is enabled for cx_Oracle assuming at least version 5.0, which
  is now commonplace.

  References: #3932

• [feature] [sql] The longstanding behavior of the ColumnOperators.in_() and
  ColumnOperators.notin_() operators emitting a warning when
  the right-hand condition is an empty sequence has been revised;
  a simple "static" expression of "1 != 1" or "1 = 1" is now rendered
  by default, rather than pulling in the original left-hand
  expression. This causes the result for a NULL column comparison
  against an empty set to change from NULL to true/false. The
  behavior is configurable, and the old behavior can be enabled
  using the create_engine.empty_in_strategy parameter
  to create_engine().

  References: #3907

• [bug] [oracle] Oracle reflection now "normalizes" the name given to a foreign key
  constraint, that is, returns it as all lower case for a case
  insensitive name. This was already the behavior for indexes
  and primary key constraints as well as all table and column names.
  This will allow Alembic autogenerate scripts to compare and render
  foreign key constraint names correctly when initially specified
  as case insensitive.

  References: #3276

• [feature] [sql] Added a new option autoescape to the "startswith" and
  "endswith" classes of comparators; this supplies an escape character
  also applies it to all occurrences of the wildcard characters "%"
  and "_" automatically. Pull request courtesy Diana Clarke.

  This feature has been changed as of 1.2.0 from its initial
  implementation in 1.2.0b2 such that autoescape is now passed as a
  boolean value, rather than a specific character to use as the escape
  character.

  References: #2694

• [bug] [orm] The state of the Session is now present when the
  SessionEvents.after_rollback() event is emitted, that is, the
  attribute state of objects prior to their being expired. This is now
  consistent with the behavior of the
  SessionEvents.after_commit() event which also emits before the
  attribute state of objects is expired.

  References: #3934

• [bug] [orm] Fixed bug where Query.with_parent() would not work if the
  Query were against an aliased() construct rather than
  a regular mapped class. Also adds a new parameter
  util.with_parent.from_entity to the standalone
  util.with_parent() function as well as
  Query.with_parent().

  References: #3607