Sqlalchemy

:released: Sat Sep 12 2009

.. change::
:tags: orm
:tickets: 1300

Fixed bug whereby inheritance discriminator part of a
composite primary key would fail on updates.
Continuation of.

.. change::
:tags: orm
:tickets: 1507

Fixed bug which disallowed one side of a many-to-many
bidirectional reference to declare itself as "viewonly"

.. change::
:tags: orm
:tickets: 1526

Added an assertion that prevents a validates function
or other AttributeExtension from loading an unloaded
collection such that internal state may be corrupted.

.. change::
:tags: orm
:tickets: 1519

Fixed bug which prevented two entities from mutually
replacing each other's primary key values within a single
flush() for some orderings of operations.

.. change::
:tags: orm
:tickets: 1485

Fixed an obscure issue whereby a joined-table subclass
with a self-referential eager load on the base class
would populate the related object's "subclass" table with
data from the "subclass" table of the parent.

.. change::
:tags: orm
:tickets: 1477

relations() now have greater ability to be "overridden",
meaning a subclass that explicitly specifies a relation()
overriding that of the parent class will be honored
during a flush. This is currently to support
many-to-many relations from concrete inheritance setups.
Outside of that use case, YMMV.

.. change::
:tags: orm
:tickets: 1483

Squeezed a few more unnecessary "lazy loads" out of
relation(). When a collection is mutated, many-to-one
backrefs on the other side will not fire off to load
the "old" value, unless "single_parent=True" is set.
A direct assignment of a many-to-one still loads
the "old" value in order to update backref collections
on that value, which may be present in the session
already, thus maintaining the 0.5 behavioral contract.

.. change::
:tags: orm
:tickets: 1480

Fixed bug whereby a load/refresh of joined table
inheritance attributes which were based on
column_property() or similar would fail to evaluate.

.. change::
:tags: orm
:tickets: 1488

Improved support for MapperProperty objects overriding
that of an inherited mapper for non-concrete
inheritance setups - attribute extensions won't randomly
collide with each other.

.. change::
:tags: orm
:tickets: 1487

UPDATE and DELETE do not support ORDER BY, LIMIT, OFFSET,
etc. in standard SQL. Query.update() and Query.delete()
now raise an exception if any of limit(), offset(),
order_by(), group_by(), or distinct() have been
called.

.. change::
:tags: orm
:tickets:

Added AttributeExtension to sqlalchemy.orm.__all__

.. change::
:tags: orm
:tickets: 1476

Improved error message when query() is called with
a non-SQL /entity expression.

.. change::
:tags: orm
:tickets: 1440

Using False or 0 as a polymorphic discriminator now
works on the base class as well as a subclass.

.. change::
:tags: orm
:tickets: 1424

Added enable_assertions(False) to Query which disables
the usual assertions for expected state - used
by Query subclasses to engineer custom state.. See
https://www.sqlalchemy.org/trac/wiki/UsageRecipes/PreFilteredQuery
for an example.

.. change::
:tags: orm
:tickets: 1501

Fixed recursion issue which occurred if a mapped object's
`__len__()` or `__nonzero__()` method resulted in state
changes.

.. change::
:tags: orm
:tickets: 1506

Fixed incorrect exception raise in
Weak/StrongIdentityMap.add()

.. change::
:tags: orm
:tickets: 1522

Fixed the error message for "could not find a FROM clause"
in query.join() which would fail to issue correctly
if the query was against a pure SQL construct.

.. change::
:tags: orm
:tickets: 1486

Fixed a somewhat hypothetical issue which would result
in the wrong primary key being calculated for a mapper
using the old polymorphic_union function - but this
is old stuff.

.. change::
:tags: sql
:tickets: 1373

Fixed column.copy() to copy defaults and onupdates.

.. change::
:tags: sql
:tickets:

Fixed a bug in extract() introduced in 0.5.4 whereby
the string "field" argument was getting treated as a
ClauseElement, causing various errors within more
complex SQL transformations.

.. change::
:tags: sql
:tickets: 1420

Unary expressions such as DISTINCT propagate their
type handling to result sets, allowing conversions like
unicode and such to take place.

.. change::
:tags: sql
:tickets: 1482

Fixed bug in Table and Column whereby passing empty
dict for "info" argument would raise an exception.

.. change::
:tags: oracle
:tickets: 1309

Backported 0.6 fix for Oracle alias names not getting
truncated.

.. change::
:tags: ext
:tickets: 1446

The collection proxies produced by associationproxy are now
pickleable. A user-defined proxy_factory however
is still not pickleable unless it defines __getstate__
and __setstate__.

.. change::
:tags: ext
:tickets: 1468

Declarative will raise an informative exception if
__table_args__ is passed as a tuple with no dict argument.
Improved documentation.

.. change::
:tags: ext
:tickets: 1527

Table objects declared in the MetaData can now be used
in string expressions sent to primaryjoin/secondaryjoin/
secondary - the name is pulled from the MetaData of the
declarative base.

.. change::
:tags: ext
:tickets: 1523

A column can be added to a joined-table subclass after
the class has been constructed (i.e. via class-level
attribute assignment). The column is added to the underlying
Table as always, but now the mapper will rebuild its
"join" to include the new column, instead of raising
an error about "no such column, use column_property()
instead".

.. change::
:tags: test
:tickets:

Added examples into the test suite so they get exercised
regularly and cleaned up a couple deprecation warnings.

.. changelog::

:released: Mon Jul 13 2009

.. change::
:tags: general
:tickets: 970

unit tests have been migrated from unittest to nose. See
README.unittests for information on how to run the tests.

.. change::
:tags: orm
:tickets:

The "foreign_keys" argument of relation() will now propagate
automatically to the backref in the same way that primaryjoin
and secondaryjoin do. For the extremely rare use case where
the backref of a relation() has intentionally different
"foreign_keys" configured, both sides now need to be
configured explicitly (if they do in fact require this setting,
see the next note...).

.. change::
:tags: orm
:tickets:

...the only known (and really, really rare) use case where a
different foreign_keys setting was used on the
forwards/backwards side, a composite foreign key that
partially points to its own columns, has been enhanced such
that the fk->itself aspect of the relation won't be used to
determine relation direction.

.. change::
:tags: orm
:tickets:

Session.mapper is now *deprecated*.

Call session.add() if you'd like a free-standing object to be
part of your session. Otherwise, a DIY version of
Session.mapper is now documented at
https://www.sqlalchemy.org/trac/wiki/UsageRecipes/SessionAwareMapper
The method will remain deprecated throughout 0.6.

.. change::
:tags: orm
:tickets: 1431

Fixed Query being able to join() from individual columns of a
joined-table subclass entity, i.e. query(SubClass.foo,
SubClass.bar).join(<anything>). In most cases, an error
"Could not find a FROM clause to join from" would be
raised. In a few others, the result would be returned in terms
of the base class rather than the subclass - so applications
which relied on this erroneous result need to be
adjusted.

.. change::
:tags: orm
:tickets: 1461

Fixed a bug involving contains_eager(), which would apply
itself to a secondary (i.e. lazy) load in a particular rare
case, producing cartesian products. improved the targeting of
query.options() on secondary loads overall.

.. change::
:tags: orm
:tickets:

Fixed bug introduced in 0.5.4 whereby Composite types fail
when default-holding columns are flushed.

.. change::
:tags: orm
:tickets: 1426

Fixed another 0.5.4 bug whereby mutable attributes
(i.e. PickleType) wouldn't be deserialized correctly when the
whole object was serialized.

.. change::
:tags: orm
:tickets:

Fixed bug whereby session.is_modified() would raise an
exception if any synonyms were in use.

.. change::
:tags: orm
:tickets:

Fixed potential memory leak whereby previously pickled objects
placed back in a session would not be fully garbage collected
unless the Session were explicitly closed out.

.. change::
:tags: orm
:tickets:

Fixed bug whereby list-based attributes, like pickletype and
PGArray, failed to be merged() properly.

.. change::
:tags: orm
:tickets:

Repaired non-working attributes.set_committed_value function.

.. change::
:tags: orm
:tickets:

Trimmed the pickle format for InstanceState which should
further reduce the memory footprint of pickled instances. The
format should be backwards compatible with that of 0.5.4 and
previous.

.. change::
:tags: orm
:tickets: 1463

sqlalchemy.orm.join and sqlalchemy.orm.outerjoin are now
added to __all__ in sqlalchemy.orm.*.

.. change::
:tags: orm
:tickets: 1458

Fixed bug where Query exception raise would fail when
a too-short composite primary key value were passed to
get().

.. change::
:tags: sql
:tickets:

Removed an obscure feature of execute() (including connection,
engine, Session) whereby a bindparam() construct can be sent
as a key to the params dictionary. This usage is undocumented
and is at the core of an issue whereby the bindparam() object
created implicitly by a text() construct may have the same
hash value as a string placed in the params dictionary and may
result in an inappropriate match when computing the final bind
parameters. Internal checks for this condition would add
significant latency to the critical task of parameter
rendering, so the behavior is removed. This is a backwards
incompatible change for any application that may have been
using this feature, however the feature has never been
documented.

.. change::
:tags: engine/pool
:tickets:

Implemented recreate() for StaticPool.

.. changelog::
:version: 0.5.4p2
:released: Tue May 26 2009

.. change::
:tags: sql
:tickets:

Repaired the printing of SQL exceptions which are not
based on parameters or are not executemany() style.

.. change::
:tags: postgresql
:tickets:

Deprecated the hardcoded TIMESTAMP function, which when
used as func.TIMESTAMP(value) would render "TIMESTAMP value".
This breaks on some platforms as PostgreSQL doesn't allow
bind parameters to be used in this context. The hard-coded
uppercase is also inappropriate and there's lots of other
PG casts that we'd need to support. So instead, use
text constructs i.e. select(["timestamp '12/05/09'"]).

.. changelog::
:version: 0.5.4p1
:released: Mon May 18 2009

.. change::
:tags: orm
:tickets:

Fixed an attribute error introduced in 0.5.4 which would
occur when merge() was used with an incomplete object.

.. changelog::

:released: Sun May 17 2009

.. change::
:tags: orm
:tickets: 1398

Significant performance enhancements regarding Sessions/flush()
in conjunction with large mapper graphs, large numbers of
objects:

- Removed all* O(N) scanning behavior from the flush() process,
i.e. operations that were scanning the full session,
including an extremely expensive one that was erroneously
assuming primary key values were changing when this
was not the case.

* one edge case remains which may invoke a full scan,
if an existing primary key attribute is modified
to a new value.

- The Session's "weak referencing" behavior is now *full* -
no strong references whatsoever are made to a mapped object
or related items/collections in its __dict__. Backrefs and
other cycles in objects no longer affect the Session's ability
to lose all references to unmodified objects. Objects with
pending changes still are maintained strongly until flush.


The implementation also improves performance by moving
the "resurrection" process of garbage collected items
to only be relevant for mappings that map "mutable"
attributes (i.e. PickleType, composite attrs). This removes
overhead from the gc process and simplifies internal
behavior.

If a "mutable" attribute change is the sole change on an object
which is then dereferenced, the mapper will not have access to
other attribute state when the UPDATE is issued. This may present
itself differently to some MapperExtensions.

The change also affects the internal attribute API, but not
the AttributeExtension interface nor any of the publicly
documented attribute functions.

- The unit of work no longer generates a graph of "dependency"
processors for the full graph of mappers during flush(), instead
creating such processors only for those mappers which represent
objects with pending changes. This saves a tremendous number
of method calls in the context of a large interconnected
graph of mappers.

- Cached a wasteful "table sort" operation that previously
occurred multiple times per flush, also removing significant
method call count from flush().

- Other redundant behaviors have been simplified in
mapper._save_obj().

.. change::
:tags: orm
:tickets:

Modified query_cls on DynamicAttributeImpl to accept a full
mixin version of the AppenderQuery, which allows subclassing
the AppenderMixin.

.. change::
:tags: orm
:tickets: 1300

The "polymorphic discriminator" column may be part of a
primary key, and it will be populated with the correct
discriminator value.

.. change::
:tags: orm
:tickets:

Fixed the evaluator not being able to evaluate IS NULL clauses.

.. change::
:tags: orm
:tickets: 1352

Fixed the "set collection" function on "dynamic" relations to
initiate events correctly. Previously a collection could only
be assigned to a pending parent instance, otherwise modified
events would not be fired correctly. Set collection is now
compatible with merge(), fixes.

.. change::
:tags: orm
:tickets:

Allowed pickling of PropertyOption objects constructed with
instrumented descriptors; previously, pickle errors would occur
when pickling an object which was loaded with a descriptor-based
option, such as query.options(eagerload(MyClass.foo)).

.. change::
:tags: orm
:tickets: 1357

Lazy loader will not use get() if the "lazy load" SQL clause
matches the clause used by get(), but contains some parameters
hardcoded. Previously the lazy strategy would fail with the
get(). Ideally get() would be used with the hardcoded
parameters but this would require further development.

.. change::
:tags: orm
:tickets: 1391

MapperOptions and other state associated with query.options()
is no longer bundled within callables associated with each
lazy/deferred-loading attribute during a load.
The options are now associated with the instance's
state object just once when it's populated. This removes
the need in most cases for per-instance/attribute loader
objects, improving load speed and memory overhead for
individual instances.

.. change::
:tags: orm
:tickets: 1360

Fixed another location where autoflush was interfering
with session.merge(). autoflush is disabled completely
for the duration of merge() now.

.. change::
:tags: orm
:tickets: 1406

Fixed bug which prevented "mutable primary key" dependency
logic from functioning properly on a one-to-one
relation().

.. change::
:tags: orm
:tickets:

Fixed bug in relation(), introduced in 0.5.3,
whereby a self referential relation
from a base class to a joined-table subclass would
not configure correctly.

.. change::
:tags: orm
:tickets:

Fixed obscure mapper compilation issue when inheriting
mappers are used which would result in un-initialized
attributes.

.. change::
:tags: orm
:tickets:

Fixed documentation for session weak_identity_map -
the default value is True, indicating a weak
referencing map in use.

.. change::
:tags: orm
:tickets: 1376

Fixed a unit of work issue whereby the foreign
key attribute on an item contained within a collection
owned by an object being deleted would not be set to
None if the relation() was self-referential.

.. change::
:tags: orm
:tickets: 1378

Fixed Query.update() and Query.delete() failures with eagerloaded
relations.

.. change::
:tags: orm
:tickets:

It is now an error to specify both columns of a binary primaryjoin
condition in the foreign_keys or remote_side collection. Whereas
previously it was just nonsensical, but would succeed in a
non-deterministic way.

.. change::
:tags: ticket: 594, 1341, schema
:tickets:

Added a quote_schema() method to the IdentifierPreparer class
so that dialects can override how schemas get handled. This
enables the MSSQL dialect to treat schemas as multipart
identifiers, such as 'database.owner'.

.. change::
:tags: sql
:tickets:

Back-ported the "compiler" extension from SQLA 0.6. This
is a standardized interface which allows the creation of custom
ClauseElement subclasses and compilers. In particular it's
handy as an alternative to text() when you'd like to
build a construct that has database-specific compilations.
See the extension docs for details.

.. change::
:tags: sql
:tickets: 1413

Exception messages are truncated when the list of bound
parameters is larger than 10, preventing enormous
multi-page exceptions from filling up screens and logfiles
for large executemany() statements.

.. change::
:tags: sql
:tickets:

``sqlalchemy.extract()`` is now dialect sensitive and can
extract components of timestamps idiomatically across the
supported databases, including SQLite.

.. change::
:tags: sql
:tickets: 1353

Fixed __repr__() and other _get_colspec() methods on
ForeignKey constructed from __clause_element__() style
construct (i.e. declarative columns).

.. change::
:tags: mysql
:tickets: 1405

Reflecting a FOREIGN KEY construct will take into account
a dotted schema.tablename combination, if the foreign key
references a table in a remote schema.

.. change::
:tags: mssql
:tickets:

Modified how savepoint logic works to prevent it from
stepping on non-savepoint oriented routines. Savepoint
support is still very experimental.

.. change::
:tags: mssql
:tickets: 1310

Added in reserved words for MSSQL that covers version 2008
and all prior versions.

.. change::
:tags: mssql
:tickets: 1343

Corrected problem with information schema not working with a
binary collation based database. Cleaned up information schema
since it is only used by mssql now.

.. change::
:tags: sqlite
:tickets: 1402

Corrected the SLBoolean type so that it properly treats only 1
as True.

.. change::
:tags: sqlite
:tickets: 1273

Corrected the float type so that it correctly maps to a
SLFloat type when being reflected.

.. change::
:tags: extensions
:tickets: 1379

Fixed adding of deferred or other column properties to a
declarative class.

.. changelog::

:released: Tue Mar 24 2009

.. change::
:tags: orm
:tickets: 1315

The "objects" argument to session.flush() is deprecated.
State which represents the linkage between a parent and
child object does not support "flushed" status on
one side of the link and not the other, so supporting
this operation leads to misleading results.

.. change::
:tags: orm
:tickets:

Query now implements __clause_element__() which produces
its selectable, which means a Query instance can be accepted
in many SQL expressions, including col.in_(query),
union(query1, query2), select([foo]).select_from(query),
etc.

.. change::
:tags: orm
:tickets: 1337

Query.join() can now construct multiple FROM clauses, if
needed. Such as, query(A, B).join(A.x).join(B.y)
might say SELECT A.*, B.* FROM A JOIN X, B JOIN Y.
Eager loading can also tack its joins onto those
multiple FROM clauses.

.. change::
:tags: orm
:tickets: 1347

Fixed bug in dynamic_loader() where append/remove events
after construction time were not being propagated to the
UOW to pick up on flush().

.. change::
:tags: orm
:tickets:

Fixed bug where column_prefix wasn't being checked before
not mapping an attribute that already had class-level
name present.

.. change::
:tags: orm
:tickets: 1315

a session.expire() on a particular collection attribute
will clear any pending backref additions as well, so that
the next access correctly returns only what was present
in the database. Presents some degree of a workaround for, although we are considering removing the
flush([objects]) feature altogether.

.. change::
:tags: orm
:tickets:

Session.scalar() now converts raw SQL strings to text()
the same way Session.execute() does and accepts same
alternative \**kw args.

.. change::
:tags: orm
:tickets:

improvements to the "determine direction" logic of
relation() such that the direction of tricky situations
like mapper(A.join(B)) -> relation-> mapper(B) can be
determined.

.. change::
:tags: orm
:tickets: 1306

When flushing partial sets of objects using session.flush([somelist]),
pending objects which remain pending after the operation won't
inadvertently be added as persistent.

.. change::
:tags: orm
:tickets: 1314

Added "post_configure_attribute" method to InstrumentationManager,
so that the "listen_for_events.py" example works again.

.. change::
:tags: orm
:tickets:

a forward and complementing backwards reference which are both
of the same direction, i.e. ONETOMANY or MANYTOONE,
is now detected, and an error message is raised.
Saves crazy CircularDependencyErrors later on.

.. change::
:tags: orm
:tickets:

Fixed bugs in Query regarding simultaneous selection of
multiple joined-table inheritance entities with common base
classes:

- previously the adaption applied to "B" on
"A JOIN B" would be erroneously partially applied
to "A".

- comparisons on relations (i.e. A.related==someb)
were not getting adapted when they should.

- Other filterings, like
query(A).join(A.bs).filter(B.foo=='bar'), were erroneously
adapting "B.foo" as though it were an "A".

.. change::
:tags: orm
:tickets: 1325

Fixed adaptation of EXISTS clauses via any(), has(), etc.
in conjunction with an aliased object on the left and
of_type() on the right.

.. change::
:tags: orm
:tickets:

Added an attribute helper method ``set_committed_value`` in
sqlalchemy.orm.attributes. Given an object, attribute name,
and value, will set the value on the object as part of its
"committed" state, i.e. state that is understood to have
been loaded from the database. Helps with the creation of
homegrown collection loaders and such.

.. change::
:tags: orm
:tickets:

Query won't fail with weakref error when a non-mapper/class
instrumented descriptor is passed, raises
"Invalid column expression".

.. change::
:tags: orm
:tickets:

Query.group_by() properly takes into account aliasing applied
to the FROM clause, such as with select_from(), using
with_polymorphic(), or using from_self().

.. change::
:tags: sql
:tickets:

An alias() of a select() will convert to a "scalar subquery"
when used in an unambiguously scalar context, i.e. it's used
in a comparison operation. This applies to
the ORM when using query.subquery() as well.

.. change::
:tags: sql
:tickets: 1302

Fixed missing _label attribute on Function object, others
when used in a select() with use_labels (such as when used
in an ORM column_property()).

.. change::
:tags: sql
:tickets: 1309

anonymous alias names now truncate down to the max length
allowed by the dialect. More significant on DBs like
Oracle with very small character limits.

.. change::
:tags: sql
:tickets:

the __selectable__() interface has been replaced entirely
by __clause_element__().

.. change::
:tags: sql
:tickets: 1299

The per-dialect cache used by TypeEngine to cache
dialect-specific types is now a WeakKeyDictionary.
This to prevent dialect objects from
being referenced forever for an application that
creates an arbitrarily large number of engines
or dialects. There is a small performance penalty
which will be resolved in 0.6.

.. change::
:tags: sqlite
:tickets:

Fixed SQLite reflection methods so that non-present
cursor.description, which triggers an auto-cursor
close, will be detected so that no results doesn't
fail on recent versions of pysqlite which raise
an error when fetchone() called with no rows present.

.. change::
:tags: postgresql
:tickets:

Index reflection won't fail when an index with
multiple expressions is encountered.

.. change::
:tags: postgresql
:tickets: 1327

Added PGUuid and PGBit types to
sqlalchemy.databases.postgres.

.. change::
:tags: postgresql
:tickets: 1327

Refection of unknown PG types won't crash when those
types are specified within a domain.

.. change::
:tags: mssql
:tickets:

Preliminary support for pymssql 1.0.1

.. change::
:tags: mssql
:tickets:

Corrected issue on mssql where max_identifier_length was
not being respected.

.. change::
:tags: extensions
:tickets:

Fixed a recursive pickling issue in serializer, triggered
by an EXISTS or other embedded FROM construct.

.. change::
:tags: extensions
:tickets:

Declarative locates the "inherits" class using a search
through __bases__, to skip over mixins that are local
to subclasses.

.. change::
:tags: extensions
:tickets:

Declarative figures out joined-table inheritance primary join
condition even if "inherits" mapper argument is given
explicitly.

.. change::
:tags: extensions
:tickets:

Declarative will properly interpret the "foreign_keys" argument
on a backref() if it's a string.

.. change::
:tags: extensions
:tickets:

Declarative will accept a table-bound column as a property
when used in conjunction with __table__, if the column is already
present in __table__. The column will be remapped to the given
key the same way as when added to the mapper() properties dict.

.. changelog::

:released: Sat Jan 24 2009

.. change::
:tags: orm
:tickets:

Further refined 0.5.1's warning about delete-orphan cascade
placed on a many-to-many relation. First, the bad news:
the warning will apply to both many-to-many as well as
many-to-one relations. This is necessary since in both
cases, SQLA does not scan the full set of potential parents
when determining "orphan" status - for a persistent object
it only detects an in-python de-association event to establish
the object as an "orphan". Next, the good news: to support
one-to-one via a foreign key or association table, or to
support one-to-many via an association table, a new flag
single_parent=True may be set which indicates objects
linked to the relation are only meant to have a single parent.
The relation will raise an error if multiple parent-association
events occur within Python.

.. change::
:tags: orm
:tickets: 1292

Adjusted the attribute instrumentation change from 0.5.1 to
fully establish instrumentation for subclasses where the mapper
was created after the superclass had already been fully
instrumented.

.. change::
:tags: orm
:tickets:

Fixed bug in delete-orphan cascade whereby two one-to-one
relations from two different parent classes to the same target
class would prematurely expunge the instance.

.. change::
:tags: orm
:tickets:

Fixed an eager loading bug whereby self-referential eager
loading would prevent other eager loads, self referential or not,
from joining to the parent JOIN properly. Thanks to Alex K
for creating a great test case.

.. change::
:tags: orm
:tickets:

session.expire() and related methods will not expire() unloaded
deferred attributes. This prevents them from being needlessly
loaded when the instance is refreshed.

.. change::
:tags: orm
:tickets: 1293

query.join()/outerjoin() will now properly join an aliased()
construct to the existing left side, even if query.from_self()
or query.select_from(someselectable) has been called.

.. change::
:tags: sql
:tickets: 1284

Further fixes to the "percent signs and spaces in column/table
names" functionality.

.. change::
:tags: mssql
:tickets: 1291

Restored convert_unicode handling. Results were being passed
on through without conversion.

.. change::
:tags: mssql
:tickets: 1282

Really fixing the decimal handling this time..

.. change::
:tags: Ticket:1289, mssql
:tickets:

Modified table reflection code to use only kwargs when
constructing tables.

.. changelog::

:released: Sat Jan 17 2009

.. change::
:tags: orm
:tickets:

Removed an internal join cache which could potentially leak
memory when issuing query.join() repeatedly to ad-hoc
selectables.

.. change::
:tags: orm
:tickets:

The "clear()", "save()", "update()", "save_or_update()"
Session methods have been deprecated, replaced by
"expunge_all()" and "add()". "expunge_all()" has also
been added to ScopedSession.

.. change::
:tags: orm
:tickets:

Modernized the "no mapped table" exception and added a more
explicit __table__/__tablename__ exception to declarative.

.. change::
:tags: orm
:tickets: 1237

Concrete inheriting mappers now instrument attributes which
are inherited from the superclass, but are not defined for
the concrete mapper itself, with an InstrumentedAttribute that
issues a descriptive error when accessed.

.. change::
:tags: orm
:tickets: 1237, 781

Added a new `relation()` keyword `back_populates`. This
allows configuration of backreferences using explicit
relations. This is required when creating
bidirectional relations between a hierarchy of concrete
mappers and another class.

.. change::
:tags: orm
:tickets: 1237

Test coverage added for `relation()` objects specified on
concrete mappers.

.. change::
:tags: orm
:tickets: 1276

Query.from_self() as well as query.subquery() both disable
the rendering of eager joins inside the subquery produced.
The "disable all eager joins" feature is available publicly
via a new query.enable_eagerloads() generative.

.. change::
:tags: orm
:tickets:

Added a rudimental series of set operations to Query that
receive Query objects as arguments, including union(),
union_all(), intersect(), except_(), intersect_all(),
except_all(). See the API documentation for
Query.union() for examples.

.. change::
:tags: orm
:tickets:

Fixed bug that prevented Query.join() and eagerloads from
attaching to a query that selected from a union or aliased union.

.. change::
:tags: orm
:tickets: 1237

A short documentation example added for bidirectional
relations specified on concrete mappers.

.. change::
:tags: orm
:tickets: 1269

Mappers now instrument class attributes upon construction
with the final InstrumentedAttribute object which remains
persistent. The `_CompileOnAttr`/`__getattribute__()`
methodology has been removed. The net effect is that
Column-based mapped class attributes can now be used fully
at the class level without invoking a mapper compilation
operation, greatly simplifying typical usage patterns
within declarative.

.. change::
:tags: orm
:tickets:

ColumnProperty (and front-end helpers such as ``deferred``) no
longer ignores unknown \**keyword arguments.

.. change::
:tags: orm
:tickets:

Fixed a bug with the unitofwork's "row switch" mechanism,
i.e. the conversion of INSERT/DELETE into an UPDATE, when
combined with joined-table inheritance and an object
which contained no defined values for the child table where
an UPDATE with no SET clause would be rendered.

.. change::
:tags: orm
:tickets: 1281

Using delete-orphan on a many-to-many relation is deprecated.
This produces misleading or erroneous results since SQLA does
not retrieve the full list of "parents" for m2m. To get delete-orphan
behavior with an m2m table, use an explicit association class
so that the individual association row is treated as a parent.

.. change::
:tags: orm
:tickets: 1281

delete-orphan cascade always requires delete cascade. Specifying
delete-orphan without delete now raises a deprecation warning.

.. change::
:tags: sql
:tickets: 1256

Improved the methodology to handling percent signs in column
names from. Added more tests. MySQL and
PostgreSQL dialects still do not issue correct CREATE TABLE
statements for identifiers with percent signs in them.

.. change::
:tags: schema
:tickets: 1214

Index now accepts column-oriented InstrumentedAttributes
(i.e. column-based mapped class attributes) as column
arguments.

.. change::
:tags: schema
:tickets:

Column with no name (as in declarative) won't raise a
NoneType error when its string output is requested
(such as in a stack trace).

.. change::
:tags: schema
:tickets: 1278

Fixed bug when overriding a Column with a ForeignKey
on a reflected table, where derived columns (i.e. the
"virtual" columns of a select, etc.) would inadvertently
call upon schema-level cleanup logic intended only
for the original column.

.. change::
:tags: declarative
:tickets:

Can now specify Column objects on subclasses which have no
table of their own (i.e. use single table inheritance).
The columns will be appended to the base table, but only
mapped by the subclass.

.. change::
:tags: declarative
:tickets:

For both joined and single inheriting subclasses, the subclass
will only map those columns which are already mapped on the
superclass and those explicit on the subclass. Other
columns that are present on the `Table` will be excluded
from the mapping by default, which can be disabled
by passing a blank `exclude_properties` collection to the
`__mapper_args__`. This is so that single-inheriting
classes which define their own columns are the only classes
to map those columns. The effect is actually a more organized
mapping than you'd normally get with explicit `mapper()`
calls unless you set up the `exclude_properties` arguments
explicitly.

.. change::
:tags: declarative
:tickets:

It's an error to add new Column objects to a declarative class
that specified an existing table using __table__.

.. change::
:tags: mysql
:tickets:

Added the missing keywords from MySQL 4.1 so they get escaped
properly.

.. change::
:tags: mssql
:tickets: 1280

Corrected handling of large decimal values with more robust
tests. Removed string manipulation on floats.

.. change::
:tags: mssql
:tickets:

Modified the do_begin handling in mssql to use the Cursor not
the Connection so it is DBAPI compatible.

.. change::
:tags: mssql
:tickets:

Corrected SAVEPOINT support on adodbapi by changing the
handling of savepoint_release, which is unsupported on mssql.

.. changelog::