- added concept of 'require_embedded' to corresponding_column.
requires that the target column be present in a sub-element of the
target selectable.
- embedded logic above more appropriate for ClauseAdapter functionality
since its trying to "pull up" clauses that represent columns within
a larger union up to the level of the union itself.
- the "direction" test against the "foreign_keys" collection apparently
works for an exact "column 'x' is present in the collection", no proxy
relationships needed.  fixes the case of relating a selectable/alias
to one of its underlying tables, probably fixes other scenarios

- put an aggressive check for "flushing object A with a collection
of B's, but you put a C in the collection" error condition -
**even if C is a subclass of B**, unless B's mapper loads polymorphically.
Otherwise, the collection will later load a "B" which should be a "C"
(since its not polymorphic) which breaks in bi-directional relationships
(i.e. C has its A, but A's backref will lazyload it as a different
instance of type "B") [ticket:500]

dont continue remote table if warning

"modernized" polymorph test, name change to "test_roundtrip"

- bindparam() names are now repeatable!  specify two
distinct bindparam()s with the same name in a single statement,
and the key will be shared.  proper positional/named args translate
at compile time.  for the old behavior of "aliasing" bind parameters
with conflicting names, specify "unique=True" - this option is
still used internally for all the auto-genererated (value-based)
     bind parameters.

cleanup; removed "separate foreign key" tests, polymorphic joined-table inheritance requires the same pk col name across tables;
added additional polymorphic load assertions

- added "fold_equivalents" argument to Join.select(), which removes
'duplicate' columns from the resulting column clause that are known to be
equivalent based on the join condition.  this is of great usage when
constructing subqueries of joins which Postgres complains about if
duplicate column names are present.
- added support to polymorphic stuff for more than one "equivalent column",
when trying to target columns in the polymorphic union; this applies
to multi-leveled inheritance
- put above-two concepts together to get the abc_inheritance tests to work
with postgres

- use_labels flag on select() wont auto-create labels for literal text
column elements, since we can make no assumptions about the text. to
create labels for literal columns, you can say "somecol AS somelabel",
or use literal_column("somecol").label("somelabel")
- quoting wont occur for literal columns when they are "proxied" into the
column collection for their selectable (is_literal flag is propigated)

added a unit test for nested session transactions

a generating testcase that tests a three-level inheritance chain (A->B->C) and all one-to-many and many-to-one relationships between
all distinct A,B,C.  still needs support for foreign key to parent table not the same col as the pk col

this test works with both one to many and many to one, but i think its intended to be one-to-many

- fixed function execution with explicit connections, when you dont
explicitly say "select()" off the function, i.e.
conn.execute(func.dosomething())

migrated (most) docstrings to pep-257 format, docstring generator using straight <pre> + trim() func
for now.  applies most of [ticket:214], compliemnts of Lele Gaifax

- more fixes to polymorphic relations, involving proper lazy-clause
generation on many-to-one relationships to polymorphic mappers
[ticket:493]

fix typo

- added "refresh-expire" cascade [ticket:492]

- correlated subqueries work inside of ORDER BY, GROUP BY

- exists() becomes useable as a standalone selectable, not just in a
WHERE clause

- a full select() construct can be passed to query.select() (which
worked anyway), but also query.selectfirst(), query.selectone() which
will be used as is (i.e. no query is compiled). works similarly to
sending the results to instances().

restored sequence back, needed by PG for the unit test

- added selectfirst(), selectfirst_by() to assign_mapper [ticket:467]

added collengths to use varchar instead of TEXT

- removed deprecated method of specifying custom collections on classes;
you must now use the "collection_class" option. the old way was
beginning to produce conflicts when people used assign_mapper(), which
now patches an "options" method, in conjunction with a relationship
named "options". (relationships take precedence over monkeypatched
assign_mapper methods).

formatting fix

formatting/cleanup

  - eager relation loading bug fixed for eager relation on multiple
  descendant classes [ticket:486]

Tested with pymssql 0.8.0
mssql: added query_timeout, fixes for passing auto_insert in dburl

fix to the fix for [ticket:454], prevent other mappers in a load operation from using the main extension option send to the query (i.e. mappers used for eager loads etc).

- added "contains_alias()" option for result set mapping to an alias of the mapped table

  - added "alias" argument to contains_eager().  use it to specify the string name
    or Alias instance of an alias used in the query for the eagerly loaded child items.
    easier to use than "decorator"

- moved SynonymProperty to interfaces, since its more generalized and synonym-aware operations
take place without knowning so much about properties
- mapper options like eagerload(), lazyload(), deferred(), will work for "synonym()" relationships [ticket:485]

removed not-always-applicable check for "polymorphic_identity"

- documented foreign_keys argument
- 0.3.5 markers

reverted unit test change

- oracle issues a log warning when a related table cant be reflected due to certain
permission errors [ticket:363]

Completed previously missed patches from tickets 422 and 415
get unit tests to work with pyodbc [ticket:481]
fix blank password on adodbapi [ticket:371]

- modified patch for [ticket:379] - detecting synonyms, dblinks in reflection.  test passes
except for DBLINK which I cannot get to work on my oracle-xe database.
- probable (also untested) fix for [ticket:363], better error message if we get None back for
remote table information (which is due to rights)

- fixes to tometadata() operation to propigate Constraints at column and table level

- fixed generation of CHECK constraints on columns [ticket:464]

- extension() query option propigates to Mapper._instance() method so that
all loading-related methods get called [ticket:454]

- moved change for [ticket:466] to ansisql, since thats the syntax for all databases.
the change is across all dialects, not just oracle

added PGInet type [ticket:444]

- added a Sequence to the unicode test tables to help Oracle
- fixed named PrimaryKeyConstraint generation on oracle [ticket:466] courtesy andrija at gmail

[ticket:463] fix to OrderedSet

commented out ImportError for now; will issue new ticket for handling dialect importerrors more effectively

- fixed oracle list of binary types to check for their presence in the module (such as BFILE not in all versions of cx_Oracle)
- removed oracle-handicap from binary unit test to test [ticket:435] fix, added an extra row containing None

- small fix to BoundMetaData to accept unicode or string URLs

better MSSSQL support for implicit sequences and auto-insert, ticket 415

Fix Fix for adodbapi bug introduced by ticket 419

Func rewrite for better unittest compatibility
Simplified transaction handling for pymssql

dont do RAWTOHEX on None

- some cleanup to the unitofwork test suite (needs much more)
- fixed relationship deletion error when one-to-many child item is moved to a new
  parent in a single unit of work [ticket:478]

revert old unittest patch for MSSQL

MSSSQL is now passing unit tests (well, some) thanks to Paul Johnston

run-time selectable DB-API modules for mssql [ticket:419]
preliminary support for pyodbc

Fix for ticket 473

Fix query.get for MSSQL tables with schema specified

- fixed relationship deletion error where parent/child with a single column as PK/FK
on the child would raise a "blank out the primary key" error, if manually deleted
or "delete" cascade without "delete-orphan" was used

- fixed argument passing to straight textual execute() on engine, connection.
can handle *args or a list instance for positional, **kwargs or a dict instance
for named args, or a list of list or dicts to invoke executemany()

- fix for very large topological sorts, courtesy ants.aasma at gmail [ticket:423]

- added support for py2.5 "with" statement with SessionTransaction [ticket:468]

- added options() method to SelectResults, equivalent to query.options() [ticket:472]

- implemented foreign_keys argument on relation() [ticket:385]
- PropertyLoader figures out accurate remote_side collection based
on foreign_keys, legacy foreignkey, primary/secondaryjoin/polymorphic
- reworked lazyloader, sync to work straight off foreign_keys/
remote_side collections

removed MissingTypeError (think it was an accidental checkin)

- added optional __table_opts__ dictionary to ActiveMapper, will send kw options to
Table objects [ticket:462]

ticket 298 plus transaction fixes for pymssql

- added PGInterval type [ticket:460]

- fixed "remote_side" in testrelationonbaseclass [ticket:461]
- added --reversetop arg to testbase to allow reversing the input collection
for topological sorts, to better reveal dependency issues

- added PrefetchingResultProxy support to pre-fetch LOB columns when they are
known to be present, fixes [ticket:435]

- added distinct() method to SelectResults.  generally should only make a difference
  when using count().

nested query will always use order_by even if distinct is present, added test case to back it up

make sure auto-reflection of remote tables working too...

- added "schema" argument to all has_table() calls, only supported so far by PG
- added basic unit test for PG reflection of tables in an alternate schema

alternate OrderedSet implementation courtesy sdobrev

added 'ascii' as default encoding in case getdefaultlocale()[1] comes up with None (see [ticket:457])

added mockdbapi to mysql dialect create to better help unit tests pass

polymorphic union uses the literal_column function for its "textual" column

- added literal_column() to specify a column clause that should not undergo any quoting
- straight text sent to select() added as literal_column
- fix for issue in [ticket:450]

OK nevermind that last commit, rolling the quoting fix back

- more quoting fixes for [ticket:450]...quoting more aggressive (but still skips already-quoted literals)
- got mysql to have "format" as default paramstyle even if mysql module not available, allows unit tests
to pass in non-mysql system for [ticket:457].  all the dialects should be changed to pass in their usual
paramstyle.

- sequences on a non-pk column will properly fire off on INSERT for PG/oracle

unit test for "cant execute"

- added a "supports_execution()" method to ClauseElement, so that individual
kinds of clauses can express if they are appropriate for executing...such as,
you can execute a "select", but not a "Table" or a "Join".

removed extra _find_cycles call

added unit test for previous checked in lazy fix

- clear_mappers() just blows away all of ArgSingleton for now
- lazy clause goes against parent.mapped_table instead of parent.local_table,
helps it to recognize self-referential condition between a descendant joined-table-inheritance mapper

- the "polymorphic_primaryjoin" again goes against the parent's non-polymorphic local table.
lazy load clause evaluation is plenty solid enough to handle it this time.
- the join_to() method on PropertyLoader takes the parent mapper as an argument and alisiazes
the primaryjoin against that mapper's selectable, so that the same primary join can be used against
the base mapper, any inheriting mapper, etc., whether or not it uses a polymorphic union (although
needs to be tested against alternate polymorphic unions added on subclasses).  fixes [ticket:448]

- improved support for complex queries embedded into "where" criterion
 for query.select() [ticket:449]
- contains_eager('foo') automatically implies eagerload('foo')
- query.options() can take a combiantion MapperOptions and tuples of MapperOptions,
so that functions can return groups
- refactoring to Aliasizer and ClauseAdapter so that they share a common base methodology,
which addresses all sql.ColumnElements instead of just schema.Column.  common list-processing
methods added.
- query.compile and eagerloader._aliasize_orderby make usage of improved list processing on
above.
- query.compile, within the "nested select generate" step processes the order_by clause using
the ClauseAdapter instead of Aliasizer since there is only one "target"

added types to genned docs

clarification to detached state

- fix to deferred so that load operation doesnt mistakenly occur when only
PK col attributes are set

further work on insuring clear_mappers() really works.  assignmapper identified
as a much trickier thing to clean out.  added a unit test so that if any new collections get introduced
we are still testing.

- fixed bug where cascade operations incorrectly included deleted collection
items in the cascade [ticket:445]

doc

updated docs for delete()

reset managed attributes on mapped classes when clear_mappers called

empty out ClassKey registry when clear_mappers() is called

fixes to quoting on "fake" column when used off its table

removed erroneous "lazy"