SQLAlchemy 0.8 Documentation

Release: 0.8.0 | Release Date: March 9, 2013
SQLAlchemy 0.8 Documentation » Changes and Migration » 0.8 Changelog

0.8 Changelog

0.8 Changelog

0.8.0

Released: March 9, 2013

Note

There are some new behavioral changes as of 0.8.0 not present in 0.8.0b2. They are present in the migration document as follows:

orm

  • [orm] [feature] A meaningful QueryableAttribute.info attribute is added, which proxies down to the .info attribute on either the schema.Column object if directly present, or the MapperProperty otherwise. The full behavior is documented and ensured by tests to remain stable.(link)

    #2675

  • [orm] [feature] Can set/change the “cascade” attribute on a relationship() construct after it’s been constructed already. This is not a pattern for normal use but we like to change the setting for demonstration purposes in tutorials.(link)

  • [orm] [feature] Added new helper function was_deleted(), returns True if the given object was the subject of a Session.delete() operation.(link)

    #2658

  • [orm] [feature] Extended the Runtime Inspection API system so that all Python descriptors associated with the ORM or its extensions can be retrieved. This fulfills the common request of being able to inspect all QueryableAttribute descriptors in addition to extension types such as hybrid_property and AssociationProxy. See Mapper.all_orm_descriptors.(link)

  • [orm] [bug] Improved checking for an existing backref name conflict during mapper configuration; will now test for name conflicts on superclasses and subclasses, in addition to the current mapper, as these conflicts break things just as much. This is new for 0.8, but see below for a warning that will also be triggered in 0.7.11.(link)

    #2674

  • [orm] [bug] Improved the error message emitted when a “backref loop” is detected, that is when an attribute event triggers a bidirectional assignment between two other attributes with no end. This condition can occur not just when an object of the wrong type is assigned, but also when an attribute is mis-configured to backref into an existing backref pair. Also in 0.7.11.(link)

    #2674

  • [orm] [bug] A warning is emitted when a MapperProperty is assigned to a mapper that replaces an existing property, if the properties in question aren’t plain column-based properties. Replacement of relationship properties is rarely (ever?) what is intended and usually refers to a mapper mis-configuration. Also in 0.7.11.(link)

    #2674

  • [orm] [bug] A clear error message is emitted if an event handler attempts to emit SQL on a Session within the after_commit() handler, where there is not a viable transaction in progress.(link)

    #2662

  • [orm] [bug] Detection of a primary key change within the process of cascading a natural primary key update will succeed even if the key is composite and only some of the attributes have changed.(link)

    #2665

  • [orm] [bug] An object that’s deleted from a session will be de-associated with that session fully after the transaction is committed, that is the object_session() function will return None.(link)

    #2658

  • [orm] [bug] Fixed bug whereby Query.yield_per() would set the execution options incorrectly, thereby breaking subsequent usage of the Query.execution_options() method. Courtesy Ryan Kelly.(link)

    #2661

  • [orm] [bug] Fixed the consideration of the between() operator so that it works correctly with the new relationship local/remote system.(link)

    #1768

  • [orm] [bug] the consideration of a pending object as an “orphan” has been modified to more closely match the behavior as that of persistent objects, which is that the object is expunged from the Session as soon as it is de-associated from any of its orphan-enabled parents. Previously, the pending object would be expunged only if de-associated from all of its orphan-enabled parents. The new flag legacy_is_orphan is added to orm.mapper() which re-establishes the legacy behavior.

    See the change note and example case at The consideration of a “pending” object as an “orphan” has been made more aggressive for a detailed discussion of this change.

    (link)

    #2655

  • [orm] [bug] Fixed the (most likely never used) “@collection.link” collection method, which fires off each time the collection is associated or de-associated with a mapped object - the decorator was not tested or functional. The decorator method is now named collection.linker() though the name “link” remains for backwards compatibility. Courtesy Luca Wehrstedt.(link)

    #2653

  • [orm] [bug] Made some fixes to the system of producing custom instrumented collections, mainly that the usage of the @collection decorators will now honor the __mro__ of the given class, applying the logic of the sub-most classes’ version of a particular collection method. Previously, it wasn’t predictable when subclassing an existing instrumented class such as MappedCollection whether or not custom methods would resolve correctly.(link)

    #2654

  • [orm] [bug] Fixed potential memory leak which could occur if an arbitrary number of sessionmaker objects were created. The anonymous subclass created by the sessionmaker, when dereferenced, would not be garbage collected due to remaining class-level references from the event package. This issue also applies to any custom system that made use of ad-hoc subclasses in conjunction with an event dispatcher. Also in 0.7.10.(link)

    #2650

  • [orm] [bug] Query.merge_result() can now load rows from an outer join where an entity may be None without throwing an error. Also in 0.7.10.(link)

    #2640

  • [orm] [bug] Fixes to the “dynamic” loader on relationship(), includes that backrefs will work properly even when autoflush is disabled, history events are more accurate in scenarios where multiple add/remove of the same object occurs.(link)

    #2637

  • [orm] [removed] The undocumented (and hopefully unused) system of producing custom collections using an __instrumentation__ datastructure associated with the collection has been removed, as this was a complex and untested feature which was also essentially redundant versus the decorator approach. Other internal simplifcations to the orm.collections module have been made as well.(link)

sql

  • [sql] [feature] Added a new argument to Enum and its base SchemaType inherit_schema. When set to True, the type will set its schema attribute of that of the Table to which it is associated. This also occurs during a Table.tometadata() operation; the SchemaType is now copied in all cases when Table.tometadata() happens, and if inherit_schema=True, the type will take on the new schema name passed to the method. The schema is important when used with the Postgresql backend, as the type results in a CREATE TYPE statement.(link)

    #2657

  • [sql] [feature] Index now supports arbitrary SQL expressions and/or functions, in addition to straight columns. Common modifiers include using somecolumn.desc() for a descending index and func.lower(somecolumn) for a case-insensitive index, depending on the capabilities of the target backend.(link)

    #695

  • [sql] [bug] The behavior of SELECT correlation has been improved such that the Select.correlate() and Select.correlate_except() methods, as well as their ORM analogues, will still retain “auto-correlation” behavior in that the FROM clause is modified only if the output would be legal SQL; that is, the FROM clause is left intact if the correlated SELECT is not used in the context of an enclosing SELECT inside of the WHERE, columns, or HAVING clause. The two methods now only specify conditions to the default “auto correlation”, rather than absolute FROM lists.(link)

    #2668

  • [sql] [bug] Fixed a bug regarding column annotations which in particular could impact some usages of the new orm.remote() and orm.local() annotation functions, where annotations could be lost when the column were used in a subsequent expression.(link)

    #1768, #2660

  • [sql] [bug] The ColumnOperators.in_() operator will now coerce values of None to null().(link)

    #2496

  • [sql] [bug] Fixed bug where Table.tometadata() would fail if a Column had both a foreign key as well as an alternate ”.key” name for the column. Also in 0.7.10.(link)

    #2643

  • [sql] [bug] insert().returning() raises an informative CompileError if attempted to compile on a dialect that doesn’t support RETURNING.(link)

    #2629

  • [sql] [bug] Tweaked the “REQUIRED” symbol used by the compiler to identify INSERT/UPDATE bound parameters that need to be passed, so that it’s more easily identifiable when writing custom bind-handling code.(link)

    #2648

schema

postgresql

  • [postgresql] [feature] Added support for Postgresql’s traditional SUBSTRING function syntax, renders as “SUBSTRING(x FROM y FOR z)” when regular func.substring() is used. Also in 0.7.11. Courtesy Gunnlaugur Þór Briem.(link)

    #2676

  • [postgresql] [feature] Added postgresql.ARRAY.Comparator.any() and postgresql.ARRAY.Comparator.all() methods, as well as standalone expression constructs. Big thanks to Audrius Kažukauskas for the terrific work here.(link)

    pull request 40

  • [postgresql] [bug] Fixed bug in postgresql.array() construct whereby using it inside of an expression.insert() construct would produce an error regarding a parameter issue in the self_group() method.(link)

mysql

  • [mysql] [feature] New dialect for CyMySQL added, courtesy Hajime Nakagami.(link)

    pull request 42

  • [mysql] [feature] GAE dialect now accepts username/password arguments in the URL, courtesy Owen Nelson.(link)

    pull request 33

  • [mysql] [bug] [gae] Added a conditional import to the gaerdbms dialect which attempts to import rdbms_apiproxy vs. rdbms_googleapi to work on both dev and production platforms. Also now honors the instance attribute. Courtesy Sean Lynch. Also in 0.7.10.(link)

    #2649

  • [mysql] [bug] GAE dialect won’t fail on None match if the error code can’t be extracted from the exception throw; courtesy Owen Nelson.(link)

    pull request 33

mssql

  • [mssql] [feature] Added mssql_include and mssql_clustered options to Index, renders the INCLUDE and CLUSTERED keywords, respectively. Courtesy Derek Harland.(link)

    pull request 35

  • [mssql] [feature] DDL for IDENTITY columns is now supported on non-primary key columns, by establishing a Sequence construct on any integer column. Courtesy Derek Harland.(link)

    #2644, pull request 32

  • [mssql] [bug] Added a py3K conditional around unnecessary .decode() call in mssql information schema, fixes reflection in Py3K. Also in 0.7.10.(link)

    #2638

  • [mssql] [bug] Fixed a regression whereby the “collation” parameter of the character types CHAR, NCHAR, etc. stopped working, as “collation” is now supported by the base string types. The TEXT, NCHAR, CHAR, VARCHAR types within the MSSQL dialect are now synonyms for the base types.(link)

oracle

  • [oracle] [bug] The cx_oracle dialect will no longer run the bind parameter names through encode(), as this is not valid on Python 3, and prevented statements from functioning correctly on Python 3. We now encode only if supports_unicode_binds is False, which is not the case for cx_oracle when at least version 5 of cx_oracle is used.(link)

misc

  • [bug] [tests] Fixed an import of “logging” in test_execute which was not working on some linux platforms. Also in 0.7.11.(link)

    #2669, pull request 41

  • [bug] [examples] Fixed a regression in the examples/dogpile_caching example which was due to the change in #2614.(link)

0.8.0b2

Released: December 14, 2012

orm

  • [orm] [feature] Added KeyedTuple._asdict() and KeyedTuple._fields to the KeyedTuple class to provide some degree of compatibility with the Python standard library collections.namedtuple().(link)

    #2601

  • [orm] [feature] Allow synonyms to be used when defining primary and secondary joins for relationships.(link)

  • [orm] [feature] [extensions] The sqlalchemy.ext.mutable extension now includes the example MutableDict class as part of the extension.(link)

  • [orm] [bug] The Query.select_from() method can now be used with a aliased() construct without it interfering with the entities being selected. Basically, a statement like this:

    ua = aliased(User)
    session.query(User.name).select_from(ua).join(User, User.name > ua.name)

    Will maintain the columns clause of the SELECT as coming from the unaliased “user”, as specified; the select_from only takes place in the FROM clause:

    SELECT users.name AS users_name FROM users AS users_1
    JOIN users ON users.name < users_1.name

    Note that this behavior is in contrast to the original, older use case for Query.select_from(), which is that of restating the mapped entity in terms of a different selectable:

    session.query(User.name).\
      select_from(user_table.select().where(user_table.c.id > 5))

    Which produces:

    SELECT anon_1.name AS anon_1_name FROM (SELECT users.id AS id,
    users.name AS name FROM users WHERE users.id > :id_1) AS anon_1

    It was the “aliasing” behavior of the latter use case that was getting in the way of the former use case. The method now specifically considers a SQL expression like expression.select() or expression.alias() separately from a mapped entity like a aliased() construct.

    (link)

    #2635

  • [orm] [bug] The MutableComposite type did not allow for the MutableBase.coerce() method to be used, even though the code seemed to indicate this intent, so this now works and a brief example is added. As a side-effect, the mechanics of this event handler have been changed so that new MutableComposite types no longer add per-type global event handlers. Also in 0.7.10.(link)

    #2624

  • [orm] [bug] A second overhaul of aliasing/internal pathing mechanics now allows two subclasses to have different relationships of the same name, supported with subquery or joined eager loading on both simultaneously when a full polymorphic load is used.(link)

    #2614

  • [orm] [bug] Fixed bug whereby a multi-hop subqueryload within a particular with_polymorphic load would produce a KeyError. Takes advantage of the same internal pathing overhaul as #2614.(link)

    #2617

  • [orm] [bug] Fixed regression where query.update() would produce an error if an object matched by the “fetch” synchronization strategy wasn’t locally present. Courtesy Scott Torborg.(link)

    #2602

engine

sql

  • [sql] [feature] The Insert construct now supports multi-valued inserts, that is, an INSERT that renders like “INSERT INTO table VALUES (...), (...), ...”. Supported by Postgresql, SQLite, and MySQL. Big thanks to Idan Kamara for doing the legwork on this one.(link)

    #2623

  • [sql] [bug] Fixed a regression caused by #2410 whereby a CheckConstraint would apply itself back to the original table during a Table.tometadata() operation, as it would parse the SQL expression for a parent table. The operation now copies the given expression to correspond to the new table.(link)

    #2633

  • [sql] [bug] Fixed bug where using server_onupdate=<FetchedValue|DefaultClause> without passing the “for_update=True” flag would apply the default object to the server_default, blowing away whatever was there. The explicit for_update=True argument shouldn’t be needed with this usage (especially since the documentation shows an example without it being used) so it is now arranged internally using a copy of the given default object, if the flag isn’t set to what corresponds to that argument. Also in 0.7.10.(link)

    #2631

  • [sql] [bug] Fixed bug whereby using a label_length on dialect that was smaller than the size of actual column identifiers would fail to render the columns correctly in a SELECT statement.(link)

    #2610

  • [sql] [bug] The DECIMAL type now honors the “precision” and “scale” arguments when rendering DDL.(link)

    #2618

  • [sql] [bug] Made an adjustment to the “boolean”, (i.e. __nonzero__) evaluation of binary expressions, i.e. x1 == x2, such that the “auto-grouping” applied by BinaryExpression in some cases won’t get in the way of this comparison. Previously, an expression like:

    expr1 = mycolumn > 2
    bool(expr1 == expr1)

    Would evaulate as False, even though this is an identity comparison, because mycolumn > 2 would be “grouped” before being placed into the BinaryExpression, thus changing its identity. BinaryExpression now keeps track of the “original” objects passed in. Additionally the __nonzero__ method now only returns if the operator is == or != - all others raise TypeError.

    (link)

    #2621

  • [sql] [bug] Fixed a gotcha where inadvertently calling list() on a ColumnElement would go into an endless loop, if ColumnOperators.__getitem__() were implemented. A new NotImplementedError is emitted via __iter__().(link)

  • [sql] [bug] Fixed bug in type_coerce() whereby typing information could be lost if the statement were used as a subquery inside of another statement, as well as other similar situations. Among other things, would cause typing information to be lost when the Oracle/mssql dialects would apply limit/offset wrappings.(link)

    #2603

  • [sql] [bug] Fixed bug whereby the ”.key” of a Column wasn’t being used when producing a “proxy” of the column against a selectable. This probably didn’t occur in 0.7 since 0.7 doesn’t respect the ”.key” in a wider range of scenarios.(link)

    #2597

postgresql

  • [postgresql] [feature] HSTORE is now available in the Postgresql dialect. Will also use psycopg2’s extensions if available. Courtesy Audrius Kažukauskas.(link)

    #2606

sqlite

  • [sqlite] [bug] More adjustment to this SQLite related issue which was released in 0.7.9, to intercept legacy SQLite quoting characters when reflecting foreign keys. In addition to intercepting double quotes, other quoting characters such as brackets, backticks, and single quotes are now also intercepted. Also in 0.7.10.(link)

    #2568

mssql

  • [mssql] [feature] Support for reflection of the “name” of primary key constraints added, courtesy Dave Moore.(link)

    #2600

  • [mssql] [bug] Fixed bug whereby using “key” with Column in conjunction with “schema” for the owning Table would fail to locate result rows due to the MSSQL dialect’s “schema rendering” logic’s failure to take .key into account. Also in 0.7.10.(link)

    #2607

oracle

  • [oracle] [bug] Fixed table reflection for Oracle when accessing a synonym that refers to a DBLINK remote database; while the syntax has been present in the Oracle dialect for some time, up until now it has never been tested. The syntax has been tested against a sample database linking to itself, however there’s still some uncertainty as to what should be used for the “owner” when querying the remote database for table information. Currently, the value of “username” from user_db_links is used to match the “owner”.(link)

    #2619

  • [oracle] [bug] The Oracle LONG type, while an unbounded text type, does not appear to use the cx_Oracle.LOB type when result rows are returned, so the dialect has been repaired to exclude LONG from having cx_Oracle.LOB filtering applied. Also in 0.7.10.(link)

    #2620

  • [oracle] [bug] Repaired the usage of .prepare() in conjunction with cx_Oracle so that a return value of False will result in no call to connection.commit(), hence avoiding “no transaction” errors. Two-phase transactions have now been shown to work in a rudimental fashion with SQLAlchemy and cx_oracle, however are subject to caveats observed with the driver; check the documentation for details. Also in 0.7.10.(link)

    #2611

firebird

  • [firebird] [bug] Added missing import for “fdb” to the experimental “firebird+fdb” dialect.(link)

    #2622

misc

  • [feature] [sybase] Reflection support has been added to the Sybase dialect. Big thanks to Ben Trofatter for all the work developing and testing this.(link)

    #1753

  • [feature] [pool] The Pool will now log all connection.close() operations equally, including closes which occur for invalidated connections, detached connections, and connections beyond the pool capacity.(link)

  • [feature] [pool] The Pool now consults the Dialect for functionality regarding how the connection should be “auto rolled back”, as well as closed. This grants more control of transaction scope to the dialect, so that we will be better able to implement transactional workarounds like those potentially needed for pysqlite and cx_oracle.(link)

    #2611

  • [feature] [pool] Added new PoolEvents.reset() hook to capture the event before a connection is auto-rolled back, upon return to the pool. Together with ConnectionEvents.rollback() this allows all rollback events to be intercepted.(link)

  • [informix] Some cruft regarding informix transaction handling has been removed, including a feature that would skip calling commit()/rollback() as well as some hardcoded isolation level assumptions on begin().. The status of this dialect is not well understood as we don’t have any users working with it, nor any access to an Informix database. If someone with access to Informix wants to help test this dialect, please let us know.(link)

0.8.0b1

Released: October 30, 2012

general

  • [general] [removed] The “sqlalchemy.exceptions” synonym for “sqlalchemy.exc” is removed fully.(link)

    #2433

  • [general] SQLAlchemy 0.8 now targets Python 2.5 and above. Python 2.4 is no longer supported.(link)

orm

  • [orm] [feature] Major rewrite of relationship() internals now allow join conditions which include columns pointing to themselves within composite foreign keys. A new API for very specialized primaryjoin conditions is added, allowing conditions based on SQL functions, CAST, etc. to be handled by placing the annotation functions remote() and foreign() inline within the expression when necessary. Previous recipes using the semi-private _local_remote_pairs approach can be upgraded to this new approach.

    (link)

    #1401

  • [orm] [feature] New standalone function with_polymorphic() provides the functionality of query.with_polymorphic() in a standalone form. It can be applied to any entity within a query, including as the target of a join in place of the “of_type()” modifier.(link)

    #2333

  • [orm] [feature] The of_type() construct on attributes now accepts aliased() class constructs as well as with_polymorphic constructs, and works with query.join(), any(), has(), and also eager loaders subqueryload(), joinedload(), contains_eager()(link)

    #1106, #2438

  • [orm] [feature] Improvements to event listening for mapped classes allows that unmapped classes can be specified for instance- and mapper-events. The established events will be automatically set up on subclasses of that class when the propagate=True flag is passed, and the events will be set up for that class itself if and when it is ultimately mapped.(link)

    #2585

  • [orm] [feature] The “deferred declarative reflection” system has been moved into the declarative extension itself, using the new DeferredReflection class. This class is now tested with both single and joined table inheritance use cases.(link)

    #2485

  • [orm] [feature] Added new core function “inspect()”, which serves as a generic gateway to introspection into mappers, objects, others. The Mapper and InstanceState objects have been enhanced with a public API that allows inspection of mapped attributes, including filters for column-bound or relationship-bound properties, inspection of current object state, history of attributes, etc.(link)

    #2208

  • [orm] [feature] Calling rollback() within a session.begin_nested() will now only expire those objects that had net changes within the scope of that transaction, that is objects which were dirty or were modified on a flush. This allows the typical use case for begin_nested(), that of altering a small subset of objects, to leave in place the data from the larger enclosing set of objects that weren’t modified in that sub-transaction.(link)

    #2452

  • [orm] [feature] Added utility feature Session.enable_relationship_loading(), supersedes relationship.load_on_pending. Both features should be avoided, however.(link)

    #2372

  • [orm] [feature] Added support for .info dictionary argument to column_property(), relationship(), composite(). All MapperProperty classes have an auto-creating .info dict available overall.(link)

  • [orm] [feature] Adding/removing None from a mapped collection now generates attribute events. Previously, a None append would be ignored in some cases. Related to.(link)

    #2229

  • [orm] [feature] The presence of None in a mapped collection now raises an error during flush. Previously, None values in collections would be silently ignored.(link)

    #2229

  • [orm] [feature] The Query.update() method is now more lenient as to the table being updated. Plain Table objects are better supported now, and additional a joined-inheritance subclass may be used with update(); the subclass table will be the target of the update, and if the parent table is referenced in the WHERE clause, the compiler will call upon UPDATE..FROM syntax as allowed by the dialect to satisfy the WHERE clause. MySQL’s multi-table update feature is also supported if columns are specified by object in the “values” dicitionary. PG’s DELETE..USING is also not available in Core yet.(link)

  • [orm] [feature] New session events after_transaction_create and after_transaction_end allows tracking of new SessionTransaction objects. If the object is inspected, can be used to determine when a session first becomes active and when it deactivates.(link)

  • [orm] [feature] The Query can now load entity/scalar-mixed “tuple” rows that contain types which aren’t hashable, by setting the flag “hashable=False” on the corresponding TypeEngine object in use. Custom types that return unhashable types (typically lists) can set this flag to False.(link)

    #2592

  • [orm] [feature] Query now “auto correlates” by default in the same way as select() does. Previously, a Query used as a subquery in another would require the correlate() method be called explicitly in order to correlate a table on the inside to the outside. As always, correlate(None) disables correlation.(link)

    #2179

  • [orm] [feature] The after_attach event is now emitted after the object is established in Session.new or Session.identity_map upon Session.add(), Session.merge(), etc., so that the object is represented in these collections when the event is called. Added before_attach event to accommodate use cases that need autoflush w pre-attached object.(link)

    #2464

  • [orm] [feature] The Session will produce warnings when unsupported methods are used inside the “execute” portion of the flush. These are the familiar methods add(), delete(), etc. as well as collection and related-object manipulations, as called within mapper-level flush events like after_insert(), after_update(), etc. It’s been prominently documented for a long time that SQLAlchemy cannot guarantee results when the Session is manipulated within the execution of the flush plan, however users are still doing it, so now there’s a warning. Maybe someday the Session will be enhanced to support these operations inside of the flush, but for now, results can’t be guaranteed.(link)

  • [orm] [feature] ORM entities can be passed to the core select() construct as well as to the select_from(), correlate(), and correlate_except() methods of select(), where they will be unwrapped into selectables.(link)

    #2245

  • [orm] [feature] Some support for auto-rendering of a relationship join condition based on the mapped attribute, with usage of core SQL constructs. E.g. select([SomeClass]).where(SomeClass.somerelationship) would render SELECT from “someclass” and use the primaryjoin of “somerelationship” as the WHERE clause. This changes the previous meaning of “SomeClass.somerelationship” when used in a core SQL context; previously, it would “resolve” to the parent selectable, which wasn’t generally useful. Also works with query.filter(). Related to.(link)

    #2245

  • [orm] [feature] The registry of classes in declarative_base() is now a WeakValueDictionary. So subclasses of “Base” that are dereferenced will be garbage collected, if they are not referred to by any other mappers/superclass mappers. See the next note for this ticket.(link)

    #2526

  • [orm] [feature] Conflicts between columns on single-inheritance declarative subclasses, with or without using a mixin, can be resolved using a new @declared_attr usage described in the documentation.(link)

    #2472

  • [orm] [feature] declared_attr can now be used on non-mixin classes, even though this is generally only useful for single-inheritance subclass column conflict resolution.(link)

    #2472

  • [orm] [feature] declared_attr can now be used with attributes that are not Column or MapperProperty; including any user-defined value as well as association proxy objects.(link)

    #2517

  • [orm] [feature] Very limited support for inheriting mappers to be GC’ed when the class itself is deferenced. The mapper must not have its own table (i.e. single table inh only) without polymorphic attributes in place. This allows for the use case of creating a temporary subclass of a declarative mapped class, with no table or mapping directives of its own, to be garbage collected when dereferenced by a unit test.(link)

    #2526

  • [orm] [feature] Declarative now maintains a registry of classes by string name as well as by full module-qualified name. Multiple classes with the same name can now be looked up based on a module-qualified string within relationship(). Simple class name lookups where more than one class shares the same name now raises an informative error message.(link)

    #2338

  • [orm] [feature] Can now provide class-bound attributes that override columns which are of any non-ORM type, not just descriptors.(link)

    #2535

  • [orm] [feature] Added with_labels and reduce_columns keyword arguments to Query.subquery(), to provide two alternate strategies for producing queries with uniquely- named columns. .(link)

    #1729

  • [orm] [feature] A warning is emitted when a reference to an instrumented collection is no longer associated with the parent class due to expiration/attribute refresh/collection replacement, but an append or remove operation is received on the now-detached collection.(link)

    #2476

  • [orm] [bug] ORM will perform extra effort to determine that an FK dependency between two tables is not significant during flush if the tables are related via joined inheritance and the FK dependency is not part of the inherit_condition, saves the user a use_alter directive.(link)

    #2527

  • [orm] [bug] The instrumentation events class_instrument(), class_uninstrument(), and attribute_instrument() will now fire off only for descendant classes of the class assigned to listen(). Previously, an event listener would be assigned to listen for all classes in all cases regardless of the “target” argument passed.(link)

    #2590

  • [orm] [bug] with_polymorphic() produces JOINs in the correct order and with correct inheriting tables in the case of sending multi-level subclasses in an arbitrary order or with intermediary classes missing.(link)

    #1900

  • [orm] [bug] Improvements to joined/subquery eager loading dealing with chains of subclass entities sharing a common base, with no specific “join depth” provided. Will chain out to each subclass mapper individually before detecting a “cycle”, rather than considering the base class to be the source of the “cycle”.(link)

    #2481

  • [orm] [bug] The “passive” flag on Session.is_modified() no longer has any effect. is_modified() in all cases looks only at local in-memory modified flags and will not emit any SQL or invoke loader callables/initializers.(link)

    #2320

  • [orm] [bug] The warning emitted when using delete-orphan cascade with one-to-many or many-to-many without single-parent=True is now an error. The ORM would fail to function subsequent to this warning in any case.(link)

    #2405

  • [orm] [bug] Lazy loads emitted within flush events such as before_flush(), before_update(), etc. will now function as they would within non-event code, regarding consideration of the PK/FK values used in the lazy-emitted query. Previously, special flags would be established that would cause lazy loads to load related items based on the “previous” value of the parent PK/FK values specifically when called upon within a flush; the signal to load in this way is now localized to where the unit of work actually needs to load that way. Note that the UOW does sometimes load these collections before the before_update() event is called, so the usage of “passive_updates” or not can affect whether or not a collection will represent the “old” or “new” data, when accessed within a flush event, based on when the lazy load was emitted. The change is backwards incompatible in the exceedingly small chance that user event code depended on the old behavior.(link)

    #2350

  • [orm] [bug] Continuing regarding extra state post-flush due to event listeners; any states that are marked as “dirty” from an attribute perspective, usually via column-attribute set events within after_insert(), after_update(), etc., will get the “history” flag reset in all cases, instead of only those instances that were part of the flush. This has the effect that this “dirty” state doesn’t carry over after the flush and won’t result in UPDATE statements. A warning is emitted to this effect; the set_committed_state() method can be used to assign attributes on objects without producing history events.(link)

    #2582, #2566

  • [orm] [bug] Fixed a disconnect that slowly evolved between a @declared_attr Column and a directly-defined Column on a mixin. In both cases, the Column will be applied to the declared class’ table, but not to that of a joined inheritance subclass. Previously, the directly-defined Column would be placed on both the base and the sub table, which isn’t typically what’s desired.(link)

    #2565

  • [orm] [bug] Declarative can now propagate a column declared on a single-table inheritance subclass up to the parent class’ table, when the parent class is itself mapped to a join() or select() statement, directly or via joined inheritance, and not just a Table.(link)

    #2549

  • [orm] [bug] An error is emitted when uselist=False is combined with a “dynamic” loader. This is a warning in 0.7.9.(link)

  • [orm] [moved] The InstrumentationManager interface and the entire related system of alternate class implementation is now moved out to sqlalchemy.ext.instrumentation. This is a seldom used system that adds significant complexity and overhead to the mechanics of class instrumentation. The new architecture allows it to remain unused until InstrumentationManager is actually imported, at which point it is bootstrapped into the core.(link)

  • [orm] [removed] The legacy “mutable” system of the ORM, including the MutableType class as well as the mutable=True flag on PickleType and postgresql.ARRAY has been removed. In-place mutations are detected by the ORM using the sqlalchemy.ext.mutable extension, introduced in 0.7. The removal of MutableType and associated constructs removes a great deal of complexity from SQLAlchemy’s internals. The approach performed poorly as it would incur a scan of the full contents of the Session when in use.(link)

    #2442

  • [orm] [removed] Deprecated identifiers removed:

    • allow_null_pks mapper() argument (use allow_partial_pks)
    • _get_col_to_prop() mapper method (use get_property_by_column())
    • dont_load argument to Session.merge() (use load=True)
    • sqlalchemy.orm.shard module (use sqlalchemy.ext.horizontal_shard)
    (link)

engine

  • [engine] [feature] Connection event listeners can now be associated with individual Connection objects, not just Engine objects.(link)

    #2511

  • [engine] [feature] The before_cursor_execute event fires off for so-called “_cursor_execute” events, which are usually special-case executions of primary-key bound sequences and default-generation SQL phrases that invoke separately when RETURNING is not used with INSERT.(link)

    #2459

  • [engine] [feature] The libraries used by the test suite have been moved around a bit so that they are part of the SQLAlchemy install again. In addition, a new suite of tests is present in the new sqlalchemy.testing.suite package. This is an under-development system that hopes to provide a universal testing suite for external dialects. Dialects which are maintained outside of SQLAlchemy can use the new test fixture as the framework for their own tests, and will get for free a “compliance” suite of dialect-focused tests, including an improved “requirements” system where specific capabilities and features can be enabled or disabled for testing.(link)

  • [engine] [feature] Added a new system for registration of new dialects in-process without using an entrypoint. See the docs for “Registering New Dialects”.(link)

    #2462

  • [engine] [feature] The “required” flag is set to True by default, if not passed explicitly, on bindparam() if the “value” or “callable” parameters are not passed. This will cause statement execution to check for the parameter being present in the final collection of bound parameters, rather than implicitly assigning None.(link)

    #2556

  • [engine] [feature] Various API tweaks to the “dialect” API to better support highly specialized systems such as the Akiban database, including more hooks to allow an execution context to access type processors.(link)

  • [engine] [feature] Inspector.get_primary_keys() is deprecated; use Inspector.get_pk_constraint(). Courtesy Diana Clarke.(link)

    #2422

  • [engine] [feature] New C extension module “utils” has been added for additional function speedups as we have time to implement.(link)

  • [engine] [bug] The Inspector.get_table_names() order_by=”foreign_key” feature now sorts tables by dependee first, to be consistent with util.sort_tables and metadata.sorted_tables.(link)

  • [engine] [bug] Fixed bug whereby if a database restart affected multiple connections, each connection would individually invoke a new disposal of the pool, even though only one disposal is needed.(link)

    #2522

  • [engine] [bug] The names of the columns on the .c. attribute of a select().apply_labels() is now based on <tablename>_<colkey> instead of <tablename>_<colname>, for those columns that have a distinctly named .key.(link)

    #2397

  • [engine] [bug] The autoload_replace flag on Table, when False, will cause any reflected foreign key constraints which refer to already-declared columns to be skipped, assuming that the in-Python declared column will take over the task of specifying in-Python ForeignKey or ForeignKeyConstraint declarations.(link)

  • [engine] [bug] The ResultProxy methods inserted_primary_key, last_updated_params(), last_inserted_params(), postfetch_cols(), prefetch_cols() all assert that the given statement is a compiled construct, and is an insert() or update() statement as is appropriate, else raise InvalidRequestError.(link)

    #2498

  • [engine] ResultProxy.last_inserted_ids is removed, replaced by inserted_primary_key.(link)

sql

  • [sql] [feature] Added a new method Engine.execution_options() to Engine. This method works similarly to Connection.execution_options() in that it creates a copy of the parent object which will refer to the new set of options. The method can be used to build sharding schemes where each engine shares the same underlying pool of connections. The method has been tested against the horizontal shard recipe in the ORM as well.

    (link)

  • [sql] [feature] Major rework of operator system in Core, to allow redefinition of existing operators as well as addition of new operators at the type level. New types can be created from existing ones which add or redefine operations that are exported out to column expressions, in a similar manner to how the ORM has allowed comparator_factory. The new architecture moves this capability into the Core so that it is consistently usable in all cases, propagating cleanly using existing type propagation behavior.(link)

    #2547

  • [sql] [feature] To complement, types can now provide “bind expressions” and “column expressions” which allow compile-time injection of SQL expressions into statements on a per-column or per-bind level. This is to suit the use case of a type which needs to augment bind- and result- behavior at the SQL level, as opposed to in the Python level. Allows for schemes like transparent encryption/ decryption, usage of Postgis functions, etc.(link)

    #1534, #2547

  • [sql] [feature] The Core oeprator system now includes the getitem operator, i.e. the bracket operator in Python. This is used at first to provide index and slice behavior to the Postgresql ARRAY type, and also provides a hook for end-user definition of custom __getitem__ schemes which can be applied at the type level as well as within ORM-level custom operator schemes. lshift (<<) and rshift (>>) are also supported as optional operators.

    Note that this change has the effect that descriptor-based __getitem__ schemes used by the ORM in conjunction with synonym() or other “descriptor-wrapped” schemes will need to start using a custom comparator in order to maintain this behavior.

    (link)

  • [sql] [feature] Revised the rules used to determine the operator precedence for the user-defined operator, i.e. that granted using the op() method. Previously, the smallest precedence was applied in all cases, now the default precedence is zero, lower than all operators except “comma” (such as, used in the argument list of a func call) and “AS”, and is also customizable via the “precedence” argument on the op() method.(link)

    #2537

  • [sql] [feature] Added “collation” parameter to all String types. When present, renders as COLLATE <collation>. This to support the COLLATE keyword now supported by several databases including MySQL, SQLite, and Postgresql.(link)

    #2276

  • [sql] [feature] Custom unary operators can now be used by combining operators.custom_op() with UnaryExpression().(link)

  • [sql] [feature] Enhanced GenericFunction and func.* to allow for user-defined GenericFunction subclasses to be available via the func.* namespace automatically by classname, optionally using a package name, as well as with the ability to have the rendered name different from the identified name in func.*.(link)

  • [sql] [feature] The cast() and extract() constructs will now be produced via the func.* accessor as well, as users naturally try to access these names from func.* they might as well do what’s expected, even though the returned object is not a FunctionElement.(link)

    #2562

  • [sql] [feature] The Inspector object can now be acquired using the new inspect() service, part of(link)

    #2208

  • [sql] [feature] The column_reflect event now accepts the Inspector object as the first argument, preceding “table”. Code which uses the 0.7 version of this very new event will need modification to add the “inspector” object as the first argument.(link)

    #2418

  • [sql] [feature] The behavior of column targeting in result sets is now case sensitive by default. SQLAlchemy for many years would run a case-insensitive conversion on these values, probably to alleviate early case sensitivity issues with dialects like Oracle and Firebird. These issues have been more cleanly solved in more modern versions so the performance hit of calling lower() on identifiers is removed. The case insensitive comparisons can be re-enabled by setting “case_insensitive=False” on create_engine().(link)

    #2423

  • [sql] [feature] The “unconsumed column names” warning emitted when keys are present in insert.values() or update.values() that aren’t in the target table is now an exception.(link)

    #2415

  • [sql] [feature] Added “MATCH” clause to ForeignKey, ForeignKeyConstraint, courtesy Ryan Kelly.(link)

    #2502

  • [sql] [feature] Added support for DELETE and UPDATE from an alias of a table, which would assumedly be related to itself elsewhere in the query, courtesy Ryan Kelly.(link)

    #2507

  • [sql] [feature] select() features a correlate_except() method, auto correlates all selectables except those passed.(link)

  • [sql] [feature] The prefix_with() method is now available on each of select(), insert(), update(), delete(), all with the same API, accepting multiple prefix calls, as well as a “dialect name” so that the prefix can be limited to one kind of dialect.(link)

    #2431

  • [sql] [feature] Added reduce_columns() method to select() construct, replaces columns inline using the util.reduce_columns utility function to remove equivalent columns. reduce_columns() also adds “with_only_synonyms” to limit the reduction just to those columns which have the same name. The deprecated fold_equivalents() feature is removed.(link)

    #1729

  • [sql] [feature] Reworked the startswith(), endswith(), contains() operators to do a better job with negation (NOT LIKE), and also to assemble them at compilation time so that their rendered SQL can be altered, such as in the case for Firebird STARTING WITH(link)

    #2470

  • [sql] [feature] Added a hook to the system of rendering CREATE TABLE that provides access to the render for each Column individually, by constructing a @compiles function against the new schema.CreateColumn construct.(link)

    #2463

  • [sql] [feature] “scalar” selects now have a WHERE method to help with generative building. Also slight adjustment regarding how SS “correlates” columns; the new methodology no longer applies meaning to the underlying Table column being selected. This improves some fairly esoteric situations, and the logic that was there didn’t seem to have any purpose.(link)

  • [sql] [feature] An explicit error is raised when a ForeignKeyConstraint() that was constructed to refer to multiple remote tables is first used.(link)

    #2455

  • [sql] [feature] Added ColumnOperators.notin_(), ColumnOperators.notlike(), ColumnOperators.notilike() to ColumnOperators.(link)

    #2580

  • [sql] [bug] Fixed bug where keyword arguments passed to Compiler.process() wouldn’t get propagated to the column expressions present in the columns clause of a SELECT statement. In particular this would come up when used by custom compilation schemes that relied upon special flags.(link)

    #2593

  • [sql] [bug] [orm] The auto-correlation feature of select(), and by proxy that of orm.Query, will not take effect for a SELECT statement that is being rendered directly in the FROM list of the enclosing SELECT. Correlation in SQL only applies to column expressions such as those in the WHERE, ORDER BY, columns clause.(link)

    #2595

  • [sql] [bug] A tweak to column precedence which moves the “concat” and “match” operators to be the same as that of “is”, “like”, and others; this helps with parenthesization rendering when used in conjunction with “IS”.(link)

    #2564

  • [sql] [bug] Applying a column expression to a select statement using a label with or without other modifying constructs will no longer “target” that expression to the underlying Column; this affects ORM operations that rely upon Column targeting in order to retrieve results. That is, a query like query(User.id, User.id.label(‘foo’)) will now track the value of each “User.id” expression separately instead of munging them together. It is not expected that any users will be impacted by this; however, a usage that uses select() in conjunction with query.from_statement() and attempts to load fully composed ORM entities may not function as expected if the select() named Column objects with arbitrary .label() names, as these will no longer target to the Column objects mapped by that entity.(link)

    #2591

  • [sql] [bug] Fixes to the interpretation of the Column “default” parameter as a callable to not pass ExecutionContext into a keyword argument parameter.(link)

    #2520

  • [sql] [bug] All of UniqueConstraint, ForeignKeyConstraint, CheckConstraint, and PrimaryKeyConstraint will attach themselves to their parent table automatically when they refer to a Table-bound Column object directly (i.e. not just string column name), and refer to one and only one Table. Prior to 0.8 this behavior occurred for UniqueConstraint and PrimaryKeyConstraint, but not ForeignKeyConstraint or CheckConstraint.(link)

    #2410

  • [sql] [bug] TypeDecorator now includes a generic repr() that works in terms of the “impl” type by default. This is a behavioral change for those TypeDecorator classes that specify a custom __init__ method; those types will need to re-define __repr__() if they need __repr__() to provide a faithful constructor representation.(link)

    #2594

  • [sql] [bug] column.label(None) now produces an anonymous label, instead of returning the column object itself, consistent with the behavior of label(column, None).(link)

    #2168

  • [sql] [changed] Most classes in expression.sql are no longer preceded with an underscore, i.e. Label, SelectBase, Generative, CompareMixin. _BindParamClause is also renamed to BindParameter. The old underscore names for these classes will remain available as synonyms for the foreseeable future.(link)

  • [sql] [removed] The long-deprecated and non-functional assert_unicode flag on create_engine() as well as String is removed.(link)

  • [sql] [change] The Text() type renders the length given to it, if a length was specified.(link)

postgresql

  • [postgresql] [feature] postgresql.ARRAY features an optional “dimension” argument, will assign a specific number of dimensions to the array which will render in DDL as ARRAY[][]..., also improves performance of bind/result processing.(link)

    #2441

  • [postgresql] [feature] postgresql.ARRAY now supports indexing and slicing. The Python [] operator is available on all SQL expressions that are of type ARRAY; integer or simple slices can be passed. The slices can also be used on the assignment side in the SET clause of an UPDATE statement by passing them into Update.values(); see the docs for examples.(link)

  • [postgresql] [feature] Added new “array literal” construct postgresql.array(). Basically a “tuple” that renders as ARRAY[1,2,3].(link)

  • [postgresql] [feature] Added support for the Postgresql ONLY keyword, which can appear corresponding to a table in a SELECT, UPDATE, or DELETE statement. The phrase is established using with_hint(). Courtesy Ryan Kelly(link)

    #2506

  • [postgresql] [feature] The “ischema_names” dictionary of the Postgresql dialect is “unofficially” customizable. Meaning, new types such as PostGIS types can be added into this dictionary, and the PG type reflection code should be able to handle simple types with variable numbers of arguments. The functionality here is “unofficial” for three reasons:

    1. this is not an “official” API. Ideally an “official” API would allow custom type-handling callables at the dialect or global level in a generic way.
    2. This is only implemented for the PG dialect, in particular because PG has broad support for custom types vs. other database backends. A real API would be implemented at the default dialect level.
    3. The reflection code here is only tested against simple types and probably has issues with more compositional types.

    patch courtesy Éric Lemoine.

    (link)

mysql

  • [mysql] [feature] Added TIME type to mysql dialect, accepts “fst” argument which is the new “fractional seconds” specifier for recent MySQL versions. The datatype will interpret a microseconds portion received from the driver, however note that at this time most/all MySQL DBAPIs do not support returning this value.(link)

    #2534

  • [mysql] [bug] Dialect no longer emits expensive server collations query, as well as server casing, on first connect. These functions are still available as semi-private.(link)

    #2404

sqlite

  • [sqlite] [feature] the SQLite date and time types have been overhauled to support a more open ended format for input and output, using name based format strings and regexps. A new argument “microseconds” also provides the option to omit the “microseconds” portion of timestamps. Thanks to Nathan Wright for the work and tests on this.(link)

    #2363

  • [sqlite] Added types.NCHAR, types.NVARCHAR to the SQLite dialect’s list of recognized type names for reflection. SQLite returns the name given to a type as the name returned.(link)

    pull request 23, rc3addcc9ffad

mssql

  • [mssql] [feature] SQL Server dialect can be given database-qualified schema names, i.e. “schema=’mydatabase.dbo’”; reflection operations will detect this, split the schema among the ”.” to get the owner separately, and emit a “USE mydatabase” statement before reflecting targets within the “dbo” owner; the existing database returned from DB_NAME() is then restored.(link)

  • [mssql] [feature] updated support for the mxodbc driver; mxodbc 3.2.1 is recommended for full compatibility.(link)

  • [mssql] [bug] removed legacy behavior whereby a column comparison to a scalar SELECT via == would coerce to an IN with the SQL server dialect. This is implicit behavior which fails in other scenarios so is removed. Code which relies on this needs to be modified to use column.in_(select) explicitly.(link)

    #2277

oracle

  • [oracle] [feature] The types of columns excluded from the setinputsizes() set can be customized by sending a list of string DBAPI type names to exclude, using the exclude_setinputsizes dialect parameter. This list was previously fixed. The list also now defaults to STRING, UNICODE, removing CLOB, NCLOB from the list.(link)

    #2561

  • [oracle] [bug] Quoting information is now passed along from a Column with quote=True when generating a same-named bound parameter to the bindparam() object, as is the case in generated INSERT and UPDATE statements, so that unknown reserved names can be fully supported.(link)

    #2437

  • [oracle] [bug] The CreateIndex construct in Oracle will now schema-qualify the name of the index to be that of the parent table. Previously this name was omitted which apparently creates the index in the default schema, rather than that of the table.(link)

firebird

  • [firebird] [feature] The “startswith()” operator renders as “STARTING WITH”, “~startswith()” renders as “NOT STARTING WITH”, using FB’s more efficient operator.(link)

    #2470

  • [firebird] [feature] An experimental dialect for the fdb driver is added, but is untested as I cannot get the fdb package to build.(link)

    #2504

  • [firebird] [bug] CompileError is raised when VARCHAR with no length is attempted to be emitted, same way as MySQL.(link)

    #2505

  • [firebird] [bug] Firebird now uses strict “ansi bind rules” so that bound parameters don’t render in the columns clause of a statement - they render literally instead.(link)

  • [firebird] [bug] Support for passing datetime as date when using the DateTime type with Firebird; other dialects support this.(link)

misc

  • [feature] [access] the MS Access dialect has been moved to its own project on Bitbucket, taking advantage of the new SQLAlchemy dialect compliance suite. The dialect is still in very rough shape and probably not ready for general use yet, however it does have extremely rudimental functionality now. https://bitbucket.org/zzzeek/sqlalchemy-access(link)

  • [moved] [maxdb] The MaxDB dialect, which hasn’t been functional for several years, is moved out to a pending bitbucket project, https://bitbucket.org/zzzeek/sqlalchemy-maxdb.(link)

  • [examples] The Beaker caching example has been converted to use dogpile.cache. This is a new caching library written by the same creator of Beaker’s caching internals, and represents a vastly improved, simplified, and modernized system of caching.

    See also

    Dogpile Caching

    (link)

    #2589