Access doesn't support savepoints or two-phase commit.

Implemented experimental savepoint support in mssql. There are still some failing savepoint related tests.

fix circular import

- Connection.invalidate() checks for closed status
to avoid attribute errors. [ticket:1246]

- PickleType now favors == comparison by default,
if the incoming object (such as a dict) implements
__eq__().  If the object does not implement
__eq__() and mutable=True, a deprecation warning
is raised.

- fixed string-based "remote_side", "order_by" and
others not propagating correctly when used in
backref().

- VERSION moves just as a string in __version__
- added modified sphinx.sty with plain Verbatim section
- link to pdf doc in site

- first() works as expected with Query.from_statement().

- reworked the "SQL assertion" code to something more flexible and based off of ConnectionProxy.  upcoming changes to dependency.py
will make use of the enhanced flexibility.

dont use names to find Annotated subclasses

- restored the previous API Reference structure
- bumped latex TOC structure, the PDF looks great
- but we need to fix the translate_connect_args docstring bug to really have PDF

fix typos

- removed redundant declarative docs
- cleanup of metadata/foreignkey docs

further fix that docstring

fixed invalid docstring example

- restored the main search form
- fixed search highlighting
- the url docstring works again from a ReST perspective, still not PDF

- moved index.rst around to have the API docs right there, no "Main Documentation" chapter which is fairly needless.  this all allows PDF to have a decent TOC on the side with only two levels (can we change that ?)
- added LatexFormatter.
- PDF wont work until issue with the docstirng in url.py/URL.translate_connect_args is fixed.

worked schema into sections

- convert __init__ and :members: to be compatible with autoclass_content='both'

fix typos

documented onupdate, partially documented server_onupdate

- re-documented Table and Column constructors, fixed case sensitivity description [ticket:1231]
- turned on autoclass_content="both".  Need to specify __init__ docstring with a newline after the """.
- other docs

Adjusted basis for refs.

- removed creepy exec call for now
- removed unnecessary isinstance() from class_mapper()
- removed unnecessary and py3k incompatible "dictionary sort" from association table delete

need to use absolutes for these, otherwise its dictionary ordering roulette

- postgres docstring
- insert/update/delete are documented generatively
- values({}) is no longer deprecated, thus enabling
unicode/Columns as keys

Enabled sphinx doctests.

remove old files

- merged -r5338:5429 of sphinx branch.
- Documentation has been converted to Sphinx.
In particular, the generated API documentation
has been constructed into a full blown
"API Reference" section which organizes
editorial documentation combined with
generated docstrings.   Cross linking between
sections and API docs are vastly improved,
a javascript-powered search feature is
provided, and a full index of all
classes, functions and members is provided.

- union() and union_all() will not whack
any order_by() that has been applied to the
select()s inside.  If you union() a
select() with order_by() (presumably to support
LIMIT/OFFSET), you should also call self_group()
on it to apply parenthesis.

- Adjusted the format of create_xid() to repair
two-phase commit.   We now have field reports
of Oracle two-phase commit working properly
with this change.

- Query.with_polymorphic() now accepts a third
argument "discriminator" which will replace
the value of mapper.polymorphic_on for that
query.  Mappers themselves no longer require
polymorphic_on to be set, even if the mapper
has a polymorphic_identity.   When not set,
the mapper will load non-polymorphically
by default. Together, these two features allow
a non-polymorphic concrete inheritance setup
to use polymorphic loading on a per-query basis,
since concrete setups are prone to many
issues when used polymorphically in all cases.

- Two fixes to help prevent out-of-band columns from
being rendered in polymorphic_union inheritance
scenarios (which then causes extra tables to be
rendered in the FROM clause causing cartesian
products):
- improvements to "column adaption" for
  a->b->c inheritance situations to better
  locate columns that are related to one
  another via multiple levels of indirection,
  rather than rendering the non-adapted
  column.
- the "polymorphic discriminator" column is
  only rendered for the actual mapper being
  queried against. The column won't be
  "pulled in" from a subclass or superclass
  mapper since it's not needed.

- Using the same ForeignKey object repeatedly
raises an error instead of silently failing
later. [ticket:1238]

- Fixed bug introduced in 0.5rc4 involving eager
loading not functioning for properties which were
added to a mapper post-compile using
add_property() or equivalent.

Modified the docstring for Session.add() with lots of help.

made Session.merge cascades not trigger autoflush

- Improved mapper() check for non-class classes.
[ticket:1236]

propagate docstrings for column/fk collections

- fixed "double iter()" call causing bus errors
in shard API, removed errant result.close()
left over from the 0.4 version. [ticket:1099]
[ticket:1228]

Refactored the entity setup code in Query so that it is not duplicated in several places.

A few more order_by statements added to the tests in order to please msql when using offsets.

- Duplicate items in a list-based collection will
be maintained when issuing INSERTs to
a "secondary" table in a many-to-many relation.
Assuming the m2m table has a unique or primary key
constraint on it, this will raise the expected
constraint violation instead of silently
dropping the duplicate entries. Note that the
old behavior remains for a one-to-many relation
since collection entries in that case
don't result in INSERT statements and SQLA doesn't
manually police collections. [ticket:1232]

deprecated CompositeProperty 'comparator' which is now
named 'comparator_factory'.

one more select_table...

- comparator_factory is accepted by all MapperProperty constructors. [ticket:1149]
- added other unit tests as per [ticket:1149]
- rewrote most of the "joined table inheritance" documentation section, removed badly out of
date "polymorphic_fetch" and "select_table" arguments.
- "select_table" raises a deprecation warning.  converted unit tests to not use it.
- removed all references to "ORDER BY table.oid" from mapping docs.
- renamed PropertyLoader to RelationProperty.  Old symbol remains.
- renamed ColumnProperty.ColumnComparator to ColumnProperty.Comparator.  Old symbol remains.

- Extra checks added to ensure explicit
primaryjoin/secondaryjoin are ClauseElement
instances, to prevent more confusing errors later
on.

- Tickets [ticket:1200].

- Added note about create_session() defaults.

- Added section about metadata.reflect().

- Updated `TypeDecorator` section.

- Rewrote the "threadlocal" strategy section of
the docs due to recent confusion over this
feature.

- ordered the init arguments in the docs for sessionmaker().

- other edits

prevent extra nested li items from becoming tiny

- Fixed the import weirdness in sqlalchemy.sql
to not export __names__ [ticket:1215].

- Comparison of many-to-one relation to NULL is
properly converted to IS NOT NULL based on not_().

- Added NotImplementedError for params() method
on Insert/Update/Delete constructs.  These items
currently don't support this functionality, which
also would be a little misleading compared to
values().

- the "passive" flag on session.is_modified()
is correctly propagated to the attribute manager.

r5281 knocked down callcounts in 2.5..

- Query.select_from(), from_statement() ensure
that the given argument is a FromClause,
or Text/Select/Union, respectively.

- Query.add_column() can accept FromClause objects
in the same manner as session.query() can.

- bump, this may become 0.5.0
- Calling alias.execute() in conjunction with
server_side_cursors won't raise AttributeError.

notes on tuning

- switched session.save() to session.add() throughout declarative test
- Fixed PendingDeprecationWarning involving order_by
parameter on relation(). [ticket:1226]
- Unit tests still filter pending deprecation warnings but have a commented-out
line to temporarily disable this behavior.  Tests need to be fully converted
before we can turn this on.

Pulled out values test that uses boolean evaluation in the SELECT in order to appropriately flag it as not supported on mssql. I sure hope I didn't jack things up for other dialects. Cleaned up a comment and removed some commented pdb statements.

Fixed a problem with the casting of a zero length type to a varchar. It now correctly adjusts the CAST accordingly.

Fixed up a lot of missing order_by statements in the tests when using offset. A lot of dialects don't really require order_by although you'll get unpredictable results. mssql does require order_by with an offset, so this fixes problems with that dialect.

The str(query) output is also correct on the mssql dialect.

- Rearranged the `load_dialect_impl()` method in
`TypeDecorator` such that it will take effect
even if the user-defined `TypeDecorator` uses
another `TypeDecorator` as its impl.

- Can now use a custom "inherit_condition" in
__mapper_args__ when using declarative.

Corrected mssql schema named subqueries from not properly aliasing the columns. Fixes #973.

Doing my part-time editorial duties. Normalized session references and fixed lots of small spelling and grammar issues.

remove errant pdb.set_trace()

- Adjustments to the enhanced garbage collection on
InstanceState to better guard against errors due
to lost state.

Quashed import sets deprecation warning on 2.6.. not wild about this but it seems like it will be ok. [ticket:1209]

- converted some more attributes to @memoized_property in expressions
- flattened an unnecessary KeyError in identity.py
- memoized the default list of mapper properties queried in MapperEntity.setup_context

- Restored "active rowcount" fetch before ResultProxy
autocloses the cursor.  This was removed in 0.5rc3.

- Restored NotImplementedError on Cls.relation.in_()
[ticket:1140] [ticket:1221]

Handle the mssql port properly. If we're using the SQL Server driver then use the correct host,port syntax, otherwise use the Port= parameter in the connection string. Fixes #1192.

Flagged another transaction test as causing mssql to hang. Need to look into these.

Corrected issue with decimal e notation that broke regular decimal tests for mssql.

If there's a zero offset with mssql just ignore it.

Corrected problem in access dialect that was still referring to the old column.foreign_key property.

flattened _get_from_objects() into a descriptor/class-bound attribute

- Removed the 'properties' attribute of the
Connection object, Connection.info should be used.
- Method consoliation in Connection, ExecutionContext

- Query.count() has been enhanced to do the "right
thing" in a wider variety of cases. It can now
count multiple-entity queries, as well as
column-based queries. Note that this means if you
say query(A, B).count() without any joining
criterion, it's going to count the cartesian
product of A*B. Any query which is against
column-based entities will automatically issue
"SELECT count(1) FROM (SELECT...)" so that the
real rowcount is returned, meaning a query such as
query(func.count(A.name)).count() will return a value of
one, since that query would return one row.

Corrected problems with Access dialect. Corrected issue with reflection due to missing Currency type. Functions didn't return the value. JOINS must be specified as LEFT OUTER JOIN or INNER JOIN. Fixes #1017.

Global propigate -> propagate change to correct spelling. Additionally found a couple of insures that should be ensure.

Corrected problems with reflection on mssql when dealing with schemas. Fixes #1217.

usage docstring for pool listener

- Query.count() and Query.get() return a more informative
error message when executed against multiple entities.
[ticket:1220]

removed setup_instance() from the public API
of ClassManager, and made it a private method on
_ClassInstrumentationAdapter.  ClassManager's approach
handles the default task with fewer function calls which chops off
a few hundred calls from the pertinent profile tests.

Fixed E notation problem in mssql. Closes #1216.

Corrected a lot of mssql limit / offset issues. Also ensured that mssql uses the IN / NOT IN syntax when using a binary expression with a subquery.

docstring updates

docstring fix

- added serializer docs to plugins.txt
- CHANGES formatting

- Fixed bug preventing declarative-bound "column" objects
from being used in column_mapped_collection().  [ticket:1174]

formatting

- zoomark adjustments
- changelog has separate category for 'features'

avoid some often unnecessary method calls.   i think we might have squeezed all we're going to squeeze out of compiler at this point.

the @memoized_property fairy pays a visit

- Repaired the table.tometadata() method so that a passed-in
schema argument is propigated to ForeignKey constructs.

- Fixed bug in Query involving order_by() in conjunction with
multiple aliases of the same class (will add tests in
[ticket:1218])
- Added a new extension sqlalchemy.ext.serializer.  Provides
Serializer/Deserializer "classes" which mirror Pickle/Unpickle,
as well as dumps() and loads().  This serializer implements
an "external object" pickler which keeps key context-sensitive
objects, including engines, sessions, metadata, Tables/Columns,
and mappers, outside of the pickle stream, and can later
restore the pickle using any engine/metadata/session provider.
This is used not for pickling regular object instances, which are
pickleable without any special logic, but for pickling expression
objects and full Query objects, such that all mapper/engine/session
dependencies can be restored at unpickle time.

add two new hooks for bulk operations to SessionExtension:

* after_bulk_delete

* after_bulk_update

- Fixed bug in composite types which prevented a primary-key
composite type from being mutated [ticket:1213].