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

slight cleanup i want in 0.5/0.6

removed needless "thread" imports from util

- sql
    - 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.

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

more fixes to bound parameter exception reporting

- added unit test for exception formatting
- Deprecated the hardcoded TIMESTAMP function, which when
used as func.TIMESTAMP(value) would render "TIMESTAMP value".
This breaks on some platforms as Postgres 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'"]).

- Repaired the printing of SQL exceptions which are not
based on parameters.

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

- 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.

unusual ...

- The "polymorphic discriminator" column may be part of a
primary key, and it will be populated with the correct
discriminator value.  [ticket:1300]

- 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. [ticket:1405]

- 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. [ticket:1413]

- 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.

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

      - 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.
        [ticket:1398]

        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 publically
        documented attribute functions.

      - The unit of work no longer genererates 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
        occured multiple times per flush, also removing significant
        method call count from flush().

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

fix mysql tests

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

- 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.

- Fixed bug which prevented "mutable primary key" dependency
logic from functioning properly on a one-to-one
relation().  [ticket:1406]
- moved MySQL to use innodb for naturalpks tests

Corrected the SQLite SLBoolean type so that it properly treats 1 only as True. Fixes #1402

- 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. [ticket:1391]

this falls back to "expire" in any case since concat_op is not supported by the evaluator

Corrected missing stop in the ORM Tutorial. Fixes #1395.

Modified savepoint logic in mssql to ensure that it does not step on non-savepoint oriented routines. Savepoint support is still very experimental.

- 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)).

Modified query_cls on DynamicAttribteImpl to accept a full mixin version of the AppenderQuery.

we work with sphinx 0.6.1 now

Query.update() and Query.delete() should turn off eagerloads. Fixes #1378.

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

Removed allow_column_override documentation. Fixes #1381.

Added copy and __copy__ methods to the OrderedDict. Fixes #1377.

Cleaned up the deprecation problems with the examples.

Corrected the sqlite float type so that it properly gets reflected as a SLFloat type. Fixes #1273.

Added in MSSQL reserved words list. Fixes #1310

Added multi part schema name support. Closes #594 and #1341.

- 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. [ticket:1376]

Corrected duplication of serializer docs. Fixes #1375.

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

test multi-level eager load without the limiting subquery

- Fixed the evaluator not being able to evaluate IS NULL clauses.
- Added evaluator tests to orm/alltests.py

disabling triggers for Mysql since it requires SUPER privs

Added indexed to the list of reserved keywords (added in 3.6.4). Fixes #1358.

Added Oracle examples showing how to use named parameters with a TNS. Fixes #1361.

Corrected examples in ORM tutorial to specify actual exception being thrown. Fixes 1365.

Corrected doc notations that suppressed some non-SQL output. Fixes #1366.

Explicit String length

add defaults to alltests

- 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.

Lots of fixes to the code examples to specify imports explicitly.

Explicit imports make it easier for users to understand the examples.
Additionally a lot of the examples were fixed to work with the changes in the
0.5.x code base. One small correction to the Case expression.  Thanks a bunch
to Adam Lowry! Fixes #717.

- Fixed another location where autoflush was interfering
with session.merge().  autoflush is disabled completely
for the duration of merge() now. [ticket:1360]

extract() is now dialect-sensitive and supports SQLite and others.

remove needless print stuff

- 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.
[ticket:1357]

- coverage dumps out separate reports for individual packages
- other coverage tips

- added a section on using aliased() with a subquery
- doctests needed huge number of +NORMALIZE_WHITESPACE not needed before for some reason

Corrected docstring for class_mapper. It does not accept an object. Fixes #1316.

Modified information_schema change to keep it backwards compatible.

fix crappity

- Fixed __repr__() and other _get_colspec() methods on
ForeignKey constructed from __clause_element__() style
construct (i.e. declarative columns).  [ticket:1353]

Corrected problem with information schema not working with binary collation on mssql. Fixes #1343.

- 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 [ticket:1352].

more tests

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

add collections module to API ref for completeness.  links to the mapper documentation
which is less wordy.

- 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.

- 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.

- 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.  [ticket:1337]

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

fix formatting to match unit tests

add schema to entity method

- 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.

take 2

attempt to exlude sqlite 3.5.9 and below, for buildbot failure.  not clear which version of sqlite fixes this particular issue

- 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().

some buildbot fixes

- updated builders for latest sphinx tip
- applied patch from [ticket:1321]

- 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.
[ticket:1315]

- Added PGUuid and PGBit types to
sqlalchemy.databases.postgres. [ticket:1327]

- Refection of unknown PG types won't crash when those
types are specified within a domain.  [ticket:1327]

- executemany() in conjunction with INSERT..RETURNING is documented as undefined by psycopg2.

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

Fix markup glitch

- pared down private and semi-private functions in the attributes package.
- simplified the process of establishment and unestablishment of
class management from a mapper perspective; class manager setup/teardown
is now symmetric (ClassManager would never be fully de-associated previously).
- class manager now unconditionally decorates __init__.  this has a slight
behavior change for an unmapped subclass of a mapped superclass, in that
InstanceState creation corresponds to that of the superclass.  This
still doesn't allow unmapped subclasses to be usable in mapper
situations, though.

- 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.

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

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

fix docstring indent in orm.util.with_parent

Corrected issue on mssql where max_identifier_length was not being respected.

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

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

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

- Declarative figures out joined-table inheritance primary join
condition even if "inherits" mapper argument is given
explicitly.  Allows mixins to be used with joined table
inheritance.

- 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.
- documented public attributes helper functions.

- annotations store 'parententity' as well as 'parentmapper'
- ORMAdapter filters all replacements against a non-compatible 'parentmapper' annotation
- Other filterings, like
query(A).join(A.bs).filter(B.foo=='bar'), were erroneously
adapting "B.foo" as though it were an "A".

Preliminary support for pymssql 1.0.1 [Ticket:1318]

- Fixed bugs in Query regarding simultaneous selection of
multiple joined-table inheritance entities with common base
classes, previously the adaption applied to "e2" on
"e1 JOIN e2" would be partially applied to "e1".  Additionally,
comparisons on relations (i.e. Entity2.related==e2)
were not getting adapted correctly.

move test by itself so that no fixture data is inserted

- 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
[ticket:1315], although we are considering removing the
flush([objects]) feature altogether.

- Added "post_configure_attribute" method to InstrumentationManager,
so that the "listen_for_events.py" example works again.
[ticket:1314]

fix Query.update docstring

- 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. [ticket:1309]