- Squashed 2.4 generators.

added an order by to fix potential mysql test failure

seems like the recent itertools add to select()._get_display_froms() adds overhead in 2.4?  not sure why

fix up some unit tests

- merge() may actually work now, though we've heard that before...
- merge() uses the priamry key attributes on the object if _instance_key not present.  so merging works for instances that dont have an instnace_key, will still issue UPDATE for existing rows.
- improved collection behavior for merge() - will remove elements from a destination collection that are not in the source.
- fixed naive set-mutation issue in Select._get_display_froms
- simplified fixtures.Base a bit

- Tighten up r4399 _set_iterable docs

- Light collections refactor, added public collections.bulk_replace.
- Collection attribs gain some private load-from-iterable flexiblity.

weird, old cruft

- removed redundant get_history() method
- the little bit at the bottom of _sort_circular_dependencies is absolutely covered by test/orm/cycles.py !  removing it breaks the test as run on PG.

C-u 66 C-x f M-q

MSSQL adjustments to pyodbc connection string building

Add a new 'driver' keyword to the MSSQL pyodbc Dialect.
Refresh items that were recently reverted by another checkin

- reverted previous "strings instead of tuples" change due to more specific test results showing tuples faster
- changed cache decorator call on default_schema_name call to a connection.info specific one

*whistle*

- Removed cache decorator.

some cache decorator calls...

using concatenated strings as keys in generated_ids collection; they hash slightly faster than tuples

- schema-qualified tables now will place the schemaname
ahead of the tablename in all column expressions as well
as when generating column labels.  This prevents cross-
schema name collisions in all cases [ticket:999]
- the "use_schema" argument to compiler.visit_column() is removed.  It uses
schema in all cases now.
- added a new test to the PG dialect to test roundtrip insert/update/delete/select
statements with full schema qualification

MSSQL fixes for tickets 979, 916, 884

- added _from_self()
- changelog authoring

- rearranged LoaderStrategies a bit
- removed awareness of "dynamic" from attributes and replaced with "impl_class"
- moved DynaLoader into dynamic.py
- removed create_strategy() method from StrategizedProperty; they set up
'strategy_class' so that StrategizedProperty treats the default the same
as the optional loaders

turned starargs conversion to a decorator, per jek's advice. select().order_by()/group_by() already take *args.

- Added PendingDeprecationWarning support
- Deprecation decorator is now a real decorator

- declarative_base() takes optional kwarg "mapper", which
is any callable/class/method that produces a mapper,
such as declarative_base(mapper=scopedsession.mapper).
This property can also be set on individual declarative
classes using the "__mapper_cls__" property.

- merged with_polymorphic branch, which was merged with query_columns branch
- removes everything to do with select_table, which remains as a keyword argument synonymous with
with_polymorphic=('*', select_table).
- all "polymorphic" selectables find their way to Query by way of _set_select_from() now, so that
all joins/aliasing/eager loads/etc. is handled consistently.  Mapper has methods for producing
polymorphic selectables so that Query and eagerloaders alike can get to them.
- row aliasing simplified, so that they don't need to nest.  they only need the source selectable
and adapt to whatever incoming columns they get.
- Query is more egalitarian about mappers/columns now.  Still has a strong sense of "entity zero",
but also introduces new unpublished/experimental _values() method which sets up a columns-only query.
- Query.order_by() and Query.group_by() take *args now (also still take a list, will likely deprecate
in 0.5).  May want to do this for select() as well.
- the existing "check for False discriminiator" "fix" was not working completely, added coverage
- orphan detection was broken when the target object was a subclass of the mapper with the orphaned
relation, fixed that too.

- can now allow selects which correlate all FROM clauses
and have no FROM themselves.  These are typically
used in a scalar context, i.e. SELECT x, (SELECT x WHERE y)
FROM table.  Requires explicit correlate() call.

- Notes for r4338

- fixed SQL function truncation of trailing underscores
[ticket:996]

- Added generic func.random (non-standard SQL)

a few more tweaks

removed AbstractClauseProcessor, merged its copy-and-visit behavior into ClauseVisitor

- already-compiled mappers will still trigger compiles of
 other uncompiled mappers when used [ticket:995]

added nicer error message to dependent class not found

 - the "owner" keyword on Table is now deprecated, and is
      exactly synonymous with the "schema" keyword.  Tables
      can now be reflected with alternate "owner" attributes,
      explicitly stated on the Table object or not using
      "schema".

    - all of the "magic" searching for synonyms, DBLINKs etc.
      during table reflection
      are disabled by default unless you specify
      "oracle_resolve_synonyms=True" on the Table object.
      Resolving synonyms necessarily leads to some messy
      guessing which we'd rather leave off by default.
      When the flag is set, tables and related tables
      will be resolved against synonyms in all cases, meaning
      if a synonym exists for a particular table, reflection
      will use it when reflecting related tables.  This is
      stickier behavior than before which is why it's
      off by default.

- inheritance in declarative can be disabled when sending
"inherits=None" to __mapper_args__.

reverted r4315 - a basic test works the way it was and fails with this change

- made some fixes to the "from_joinpoint" argument to
query.join() so that if the previous join was aliased
and this one isn't, the join still happens successfully.

- adjusted the definition of "self-referential" to be
any two mappers with a common parent (this affects
whether or not aliased=True is required when joining
with Query).

Undoing patch #994, for now; more testing needed.  Sorry.  Also modifying test for query equivalence to account for underscoring of bind variables.

adding zzzeek's patch from ticket #994, which fixed virtually all remaining broken unit tests in the Oracle module

bugfix: preserving remote_owner during reflecttable setup of referential integrity

added a runtime-incrementing counter for default primary keys to testlib/schema for Oracle

added escape kw arg to contains(), startswith(), endswith(), [ticket:791]

- like() and ilike() take an optional keyword argument
"escape=<somestring>", which is set as the escape character
using the syntax "x LIKE y ESCAPE '<somestring>'"
[ticket:993]

- symbols now depickle properly
- fixed some symbol __new__ abuse

typo

test not supported on sqlite

some fixup to one-to-many delete cascade

- fixed/added coverage for various cascade scenarios
- added coverage for some extra cases in dynamic relations
- removed some unused methods from unitofwork

- added support for declarative deferred(Column(...))
- changed "instrument" argument on synonym() to "descriptor", for consistency with comparable_proeprty()

- Column._set_parent will complete the key==name contract for instances constructed anonymously

- reST fixes

mapper double checks that columns in _compile_property are in the _cols_by_table collection

- Start coverage for Class.prop = Column(), promote nameless Columns

- Declarative will complete setup for Columns lacking names, allows
  a more DRY syntax.

    class Foo(Base):
        __tablename__ = 'foos'
        id = Column(Integer, primary_key=True)

- fixed order_by calculation in Query to properly alias
mapper-config'ed order_by when using select_from()

- 'name' is no longer a require constructor argument for Column().  It (and .key) may now be deferred until the Column is added to a Table.

- Declarative gains @synonym_for and @comparable_using decorators

- Added comparable_property(), adds query Comparator behavior to regular, unmanaged Python properties
- Some aspects of MapperProperty initialization are streteched pretty thin now
  and need a refactor; will proceed with these on the user_defined_state branch

- trailing whitespace...

- DEFAULT VALUES again.

- fixed "cascade delete" operation of dynamic relations,
which had only been implemented for foreign-key nulling
behavior in 0.4.2 and not actual cascading deletes
[ticket:895]

fix datatypes #2

fix insert() to have values (supports buildbot's SQLite)

- Fixed descriminator col type for poly test

Issue a warning when a declarative detects a likely trailing comma: foo = Column(foo),

- the "synonym" function is now directly usable with
"declarative".  Pass in the decorated property using
the "instrument" keyword argument, e.g.:
somekey = synonym('_somekey', instrument=property(g, s))
- declared_synonym deprecated

Session.execute can now find binds from metadata

- fixed bug which was preventing synonym() attributes
from being used with inheritance

typo

- fixed missing import [ticket:989]

add relate(), entity() methods

- fixed/covered case when using a False value as a
polymorphic discriminator

- when attributes are expired on a pending instance, an
error will not be raised when the "refresh" action
is triggered and returns no result

- Retroactive textmate damage control

Bump.

more edits

fix a typo....

(Whoops,)

- Take broken mysql 4.1 column defaulting into account.

- Don't create implicit DDL column defaults

- increased assert_tabels_equal failure verbosity

filled in some of the types documentation

updated SQL output, fixed String/Text type

reflection tests require foreign key reflection support

- fix expunging of orphans with more than one parent
- move flush error for orphans from Mapper to UnitOfWork

remove redundant test_rekey() test method

- Test autoload with a FK override

- Added a primaryjoin= test

eh, that __autoload_with__ idea was half baked.

- Added __autoload__ = True for declarative
- declarative Base.__init__ is pickier about its kwargs

removed the "__main__" code from below

- a new super-small "declarative" extension has been added,
which allows Table and mapper() configuration to take place
inline underneath a class declaration.  This extension differs
from ActiveMapper and Elixir in that it does not redefine
any SQLAlchemy semantics at all; literal Column, Table
and relation() constructs are used to define the class
behavior and table definition.

- relation() can accept a callable for its first argument,
which returns the class to be related.  This is in place
to assist declarative packages to define relations without
classes yet being in place.

- dynamic_loader() / lazy="dynamic" now accepts and uses
the order_by parameter in the same way in which it works
with relation().

added sanity test for order_by

Added support for vendor-extended INSERT syntax like INSERT DELAYED INTO

weed whacking is not Nones

- moved property._is_self_referential() to be more generalized; returns True for any mapper.isa() relationship between parent and child, and indicates that aliasing should be used for any join/correlation across the relation.  allows joins/any()/has() to work with inherited mappers referencing the parent etc.
- the original _is_self_referential() is now _refers_to_parent_table() and is only used during "direction" calculation to indicate the relation is from a single table to itself

corrected assert_raises to be consistent with existing assertRaises() unittest method