github sqlalchemy/sqlalchemy rel_1_2_0b1
1.2.0b1

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

latest releases: rel_1_3_20, rel_1_3_19, rel_1_3_18...
pre-release13 months ago