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

need sizes for mysql

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

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

fix docstring typo

- 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()).  [ticket:1302]

Added a few IDENTITY tests for mssql.

detect backref string as basestring, not str. [ticket:1301]

appease older sqlite version

fix serialize

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

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

some docstring stuff

unit test fixes

- _CalculatedClause is gone
- Function rolls the various standalone execution functionality of CC into itself,
accesses its internal state more directly
- collate just uses _BinaryExpression, don't know why it didn't do this already
- added new _Case construct, compiles directly
- the world is a happier place

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

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

further fixes to sphinx.sty per progress on the sphinx trunk

create correct hyperlink for the pdf file

- 0.5.3
- add new directives to sphinx.sty.  pdf output is still currently busted for other reasons, however.

- refined and clarified query.__join() for readability
- _ORMJoin() gets a new flag join_to_left to specify if
we really want to alias from the existing left side or not.  eager loading
wants this flag off in almost all cases, query.join() usually wants it on.
- 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.
[ticket:1293]

moved the non-expire of unloaded deferred attributes into the attributes package

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

Correction to reflection fix r5718 to handle Binary / other numeric types.

mssql: modified table reflection code to use only kwargs when constructing coldefs.

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

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