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

removed various print statements

added regexp search for "schema" in sequence reflection for [ticket:442], courtesy david.mugnai@spacespa.it

merged the polymorphic relationship refactoring branch in.  i want to go further on that branch and introduce the foreign_keys argument, and further centralize the "intelligence" about the joins and selectables into PropertyLoader so that lazyloader/sync can be simplified, but the current branch goes pretty far.
  - relations keep track of "polymorphic_primaryjoin", "polymorphic_secondaryjoin" which it derives from the plain primaryjoin/secondaryjoin.
  - lazy/eagerloaders work from those polymorphic join objects.
  - the join exported by PropertyLoader to Query/SelectResults is the polymorphic join, so that join_to/etc work properly.
  - Query builds itself against the base Mapper again, not the "polymorphic" mapper.  uses the "polymorphic" version
 only as appropriate.  this helps join_by/join_to/etc to work with polymorphic mappers.
  - Query will also adapt incoming WHERE criterion to the polymorphic mapper, i.e. the "people" table becomes the "person_join" automatically.
  - quoting has been modified since labels made out of non-case-sensitive columns could themselves require quoting..so case_sensitive defaults to True if not otherwise specified (used to be based on the identifier itself).
  - the test harness gets an ORMTest base class and a bunch of the ORM unit tests are using it now, decreases a lot of redundancy.

fixed "eager=True"

- added a standardized test harness for ORM tests
- added three-level mapping test.  needed some massaging for postgres

- fix for multi-level polymorphic mappers

- eager relation to an inheriting mapper wont fail if no rows returned for
the relationship.

added a close() to the single SQL execute, useful for testing pool behavior with the ORM

removed print line

pool_size was there already of course :-|

r/m unused import

add pool_size to "list of all standard options"

- fix to reflection on older DB's that might return array() type for
"show variables like" statements

- calling corresponding_column with keys_ok matches columns on name, not key, since
the name is meaningful with regards to SQL relationships, the key is not
- adjustments to the recent polymorphic relationship refactorings, specifically
for many-to-one relationships to polymorphic unions that did not contain the
base table [ticket:439].  the lazy/eager clause adaption to the selectable
will match up on straight column names (i.e. its a more liberal policy)
- lazy loader will not attempt to adapt the clause to the selectable if
loads_polymorphic is not enabled, since the more liberal policy of adapting
columns fails for more elaborate join conditions
- will have to see if ppl want to do complex joins with polymorphic relations...
may have to add "polymorphic_primaryjoin" in that case as a last resort (would make
working around these issues a snap, tho...)

added unit tests illustrating current workaround for assignmapper method name/collection class collision

raise exception if invalid collection class used

changeset

oracle can conditionally decide if it wants to say "use rowid" in a select statement.
needs to be tweaked vs. when ROW NUMBER OVER ORDER BY is being used, but currently
fixes [ticket:436]

note support for LIMIT in firebird and mssql

formatting

test patches from [ticket:422]

- *slight* support for binary, but still need to figure out how to insert reasonably large
values (over 4K).  requires auto_setinputsizes=True sent to create_engine(), rows must
be fully fetched individually, etc.

attempting to get oracle binary working

0.3.4

- added support for column "key" attribute to be useable in row[<key>]/row.<key>

justify text

add example of joining to labeled table

split out SelectableClassType from TableClassType, so we don't have to do an isinstance check for each dml op

relationships no longer compile against the "selectable" mapper (i.e. the polymorphic mapper).  join conditions, foreign keys etc. are configured against the actual mappers used in the relationship in all cases.  the lazy and eager loaders in turn "adapt" their lazy/eager clauses to that of the "selectable" mapper if one is present.  this is because the join conditions between the mapper's base tables are *far* easier to work with and detect direction etc. compared to an enormous polymorphic union; dealing with the polymorphic union is pushed further out into select query construction.

added "instances" to assign_mapper funcs  [ticket:433]

added a session transaction test

oops, change from yesterday fails the zblog tests...now i understand !

better error message from [ticket:429]

added merge unit test from [ticket:430]

added recursion check to merge

selectby -> select_by

docs:  [ticket:345], [ticket:356], [ticket:48], [ticket:403], [ticket:394],
cleanup/completion of keyword arg documentation for create_engine(), mapper(), and
relation()

- mysql table create options work on a generic passthru now, i.e. Table(..., mysql_engine='InnoDB',
mysql_collate="latin1_german2_ci", mysql_auto_increment="5", mysql_<somearg>...),
helps [ticket:418]

- added "validate=False" argument to assign_mapper, if True will insure that only mapped
attributes are named [ticket:426]

starting to refactor adaptation of inherited properties out of the MapperProperty and into the mapper for now

- tightened down conditions used to locate "relation direction", associating
  the "foreignkey" of the relationship with the "primaryjoin".  the column match now
  must be exact, not just "corresponding".  this enables self-referential relationships on a
  polymorphic mapper.
  - a little bit of improvement to the concept of a "concrete" inheritance mapping, though that concept
  is not well fleshed out yet (added test case to support concrete mappers on top of a polymorphic base).

removed

- fix to "proxy=True" behavior on synonym()