fix some profiles for 2.4

fix non2.4 gremlin

dont need this anymore

merge 0.6 series to trunk.

disabled examples test pending necesary repairs

- UPDATE and DELETE do not support ORDER BY, LIMIT, OFFSET,
etc. in standard SQL.  Query.update() and Query.delete()
now raise an exception if any of limit(), offset(),
order_by(), group_by(), or distinct() have been
called. [ticket:1487]

- Simplified the sweep of instrumentation in strategies._register_attribute

- Improved support for MapperProperty objects overriding
that of an inherited mapper for non-concrete
inheritance setups - attribute extensions won't randomly
collide with each other.  [ticket:1488]

- Added AttributeExtension to sqlalchemy.orm.__all__

backported 0.6 r6084 fix for oracle alias names, [ticket:1309]

fix broken orm debug logging

merged [ticket:1486] fix from 0.6

Reverted my screw up of setup.cfg

Corrected examples tests. I was running from ./test instead of root.

Added in Examples into the test suite so they get exercised regularly. Cleaned up some deprecation warnings in the examples.

Corrected annoying deprecation warning on 2.6+ related to mssql and the __new__ calls.

Corrected problem with binary test on mssql. Still having issues with prepared statements.

- Squeezed a few more unnecessary "lazy loads" out of
relation().  When a collection is mutated, many-to-one
backrefs on the other side will not fire off to load
the "old" value, unless "single_parent=True" is set.
A direct assignment of a many-to-one still loads
the "old" value in order to update backref collections
on that value, which may be present in the session
already, thus maintaining the 0.5 behavioral contract.
[ticket:1483]

- Fixed bug in Table and Column whereby passing empty
dict for "info" argument would raise an exception.
[ticket:1482]

- Fixed bug whereby a load/refresh of joined table
inheritance attributes which were based on
column_property() or similar would fail to evaluate.
[ticket:1480]

- Declarative will raise an informative exception if
__table_args__ is passed as a tuple with no dict argument.
Improved documentation.  [ticket:1468]

- fixed the test for FalseDiscriminator to use Boolean for picky postgresql
- added Query.enable_assertions(False) as a mediocre solution for [ticket:1424].
updated the recipe at http://www.sqlalchemy.org/trac/wiki/UsageRecipes/PreFilteredQuery to
reflect.
- moved most default Query state to be class level variables to start.  the dicts could
go as well but being overly careful to not place mutables there for the moment.
- a visit by the "dunder-private method names aren't cool" police
- continued undisciplined pep-8ness

- Using False or 0 as a polymorphic discriminator now
works on the base class as well as a subclass.
[ticket:1440]

- Unary expressions such as DISTINCT propagate their
type handling to result sets, allowing conversions like
unicode and such to take place.  [ticket:1420]

- Improved error message when query() is called with
a non-SQL /entity expression. [ticket:1476]

beefed up documentation for count(), [ticket:1465]

- The collection proxies produced by associationproxy are now
pickleable.  A user-defined proxy_factory however
is still not pickleable unless it defines __getstate__
and __setstate__. [ticket:1446]

Fix small typos in docstring

ensure "rowswitch" for isdelete is supported

- relations() now have greater ability to be "overridden",
meaning a subclass that explicitly specifies a relation()
overriding that of the parent class will be honored
during a flush.  This is currently to support
many-to-many relations from concrete inheritance setups.
Outside of that use case, YMMV.  [ticket:1477]

- Fixed bug whereby inheritance discriminator part of a
composite primary key would fail on updates.
Continuation of [ticket:1300].

- Fixed a bug in extract() introduced in 0.5.4 whereby
the string "field" argument was getting treated as a
ClauseElement, causing various errors within more
complex SQL transformations.

Guard against a gc hitting during the sweep for dirty objects.

beefed up the description of dialects

changed reference to PostgreSQL in docs.

- remove docs about partial flush, add docs about disabling autoflush

- sqlalchemy.orm.join and sqlalchemy.orm.outerjoin are now
added to __all__ in sqlalchemy.orm.*. [ticket:1463]

- Fixed bug where Query exception raise would fail when
a too-short composite primary key value were passed to
get().  [ticket:1458]

- rearranged CHANGES for 0.5.5 to be somewhat severity based.

- commented on [ticket:1445]

updates

Formatting

Implemented recreate() for StaticPool

- Fixed potential memory leak whereby previously pickled objects
placed back in a session would not be fully garbage collected
unless the Session were explicitly closed out.

- Fixed bug whereby session.is_modified() would raise an exception
if any synonyms were in use.

- Fixed a bug involving contains_eager(), which would apply itself
to a secondary (i.e. lazy) load in a particular rare case,
producing cartesian products.   improved the targeting
of query.options() on secondary loads overall [ticket:1461].

Session.mapper is now *deprecated*.
Call session.add() if you'd like a free-standing object to be
part of your session.  Otherwise, a DIY version of
Session.mapper is now documented at
http://www.sqlalchemy.org/trac/wiki/UsageRecipes/SessionAwareMapper
The method will remain deprecated throughout 0.6.

M    test/ext/test_declarative.py
M    test/orm/test_scoping.py
M    lib/sqlalchemy/orm/scoping.py
M    CHANGES

Fix deprecated usage of  on numeric type

added docs for post_update

- repaired non-working attributes.set_committed_value function.

- Trimmed the pickle format for InstanceState which should further
reduce the memory footprint of pickled instances.  The format
should be backwards compatible with that of 0.5.4 and previous.

assoc proxy object appends to list automatically [ticket:1351]

added test to verify #1423

- Fixed bug whereby list-based attributes, like pickletype
and PGArray, failed to be merged() properly.

split CHANGES into CHANGES and CHANGES_PRE_05, since I would like CHANGES to be viewable in trac

- The "foreign_keys" argument of relation() will now propagate
automatically to the backref in the same way that
primaryjoin and secondaryjoin do.   For the extremely
rare use case where the backref of a relation() has
intentionally different "foreign_keys" configured, both sides
now need to be configured explicity (if they do in fact require
this setting, see the next note...).

- ...the only known (and really, really rare) use case where a
different foreign_keys setting was used on the forwards/backwards
side, a composite foreign key that partially points to its own
columns, has been enhanced such that the fk->itself aspect of the
relation won't be used to determine relation direction.

- unit tests have been migrated from unittest to nose.
See README.unittests for information on how to run
the tests.  [ticket:970]

- Fixed Query being able to join() from individual columns of
a joined-table subclass entity, i.e.
query(SubClass.foo, SubcClass.bar).join(<anything>).
In most cases, an error "Could not find a FROM clause to join
from" would be raised. In a few others, the result would be
returned in terms of the base class rather than the subclass -
so applications which relied on this erroneous result need to be
adjusted. [ticket:1431]

- removed test.testing.ORMTest, test.fixtures, and all
dependencies on those.

move from pXXX to 0.5.5 [ticket:1427]

- Fixed another 0.5.4 bug whereby mutable attributes (i.e. PickleType)
wouldn't be deserialized correctly when the whole object
was serialized.  [ticket:1426]

slight cleanup i want in 0.5/0.6

removed needless "thread" imports from util

- sql
    - Removed an obscure feature of execute() (including connection,
      engine, Session) whereby a bindparam() construct can be sent as
      a key to the params dictionary.  This usage is undocumented
      and is at the core of an issue whereby the bindparam() object
      created implicitly by a text() construct may have the same
      hash value as a string placed in the params dictionary and
      may result in an inappropriate match when computing the final
      bind parameters.   Internal checks for this condition would
      add significant latency to the critical task of parameter
      rendering, so the behavior is removed.  This is a backwards
      incompatible change for any application that may have been
      using this feature, however the feature has never been
      documented.

- Fixed bug introduced in 0.5.4 whereby Composite types
fail when default-holding columns are flushed.

more fixes to bound parameter exception reporting

- added unit test for exception formatting
- Deprecated the hardcoded TIMESTAMP function, which when
used as func.TIMESTAMP(value) would render "TIMESTAMP value".
This breaks on some platforms as Postgres doesn't allow
bind parameters to be used in this context.  The hard-coded
uppercase is also inappropriate and there's lots of other
PG casts that we'd need to support.  So instead, use
text constructs i.e. select(["timestamp '12/05/09'"]).

- Repaired the printing of SQL exceptions which are not
based on parameters.

- Fixed an attribute error introduced in 0.5.4 which would
occur when merge() was used with an incomplete object.

- Back-ported the "compiler" extension from SQLA 0.6.  This
is a standardized interface which allows the creation of custom
ClauseElement subclasses and compilers.  In particular it's
handy as an alternative to text() when you'd like to
build a construct that has database-specific compilations.
See the extension docs for details.

unusual ...

- The "polymorphic discriminator" column may be part of a
primary key, and it will be populated with the correct
discriminator value.  [ticket:1300]

- Reflecting a FOREIGN KEY construct will take into account
a dotted schema.tablename combination, if the foreign key
references a table in a remote schema. [ticket:1405]

- Exception messages are truncated when the list of bound
parameters is larger than 10, preventing enormous
multi-page exceptions from filling up screens and logfiles
for large executemany() statements. [ticket:1413]

- Removed all* O(N) scanning behavior from the flush() process,
i.e. operations that were scanning the full session,
including an extremely expensive one that was erroneously
assuming primary key values were changing when this
was not the case.

* one edge case remains which may invoke a full scan,
  if an existing primary key attribute is modified
  to a new value.

- Significant performance enhancements regarding Sessions/flush()
      in conjunction with large mapper graphs, large numbers of
      objects:

      - The Session's "weak referencing" behavior is now *full* -
        no strong references whatsoever are made to a mapped object
        or related items/collections in its __dict__.  Backrefs and
        other cycles in objects no longer affect the Session's ability
        to lose all references to unmodified objects.  Objects with
        pending changes still are maintained strongly until flush.
        [ticket:1398]

        The implementation also improves performance by moving
        the "resurrection" process of garbage collected items
        to only be relevant for mappings that map "mutable"
        attributes (i.e. PickleType, composite attrs).  This removes
        overhead from the gc process and simplifies internal
        behavior.

        If a "mutable" attribute change is the sole change on an object
        which is then dereferenced, the mapper will not have access to
        other attribute state when the UPDATE is issued.  This may present
        itself differently to some MapperExtensions.

        The change also affects the internal attribute API, but not
        the AttributeExtension interface nor any of the publically
        documented attribute functions.

      - The unit of work no longer genererates a graph of "dependency"
        processors for the full graph of mappers during flush(), instead
        creating such processors only for those mappers which represent
        objects with pending changes.  This saves a tremendous number
        of method calls in the context of a large interconnected
        graph of mappers.

      - Cached a wasteful "table sort" operation that previously
        occured multiple times per flush, also removing significant
        method call count from flush().

      - Other redundant behaviors have been simplified in
        mapper._save_obj().

fix mysql tests

- Fixed obscure mapper compilation issue when inheriting
mappers are used which would result in un-initialized
attributes.

- It is now an error to specify both columns of a binary primaryjoin
condition in the foreign_keys or remote_side collection.  Whereas
previously it was just nonsensical, but would succeed in a
non-deterministic way.

- Fixed bug which prevented "mutable primary key" dependency
logic from functioning properly on a one-to-one
relation().  [ticket:1406]
- moved MySQL to use innodb for naturalpks tests

Corrected the SQLite SLBoolean type so that it properly treats 1 only as True. Fixes #1402

- MapperOptions and other state associated with query.options()
is no longer bundled within callables associated with each
lazy/deferred-loading attribute during a load.
The options are now associated with the instance's
state object just once when it's populated.  This removes
the need in most cases for per-instance/attribute loader
objects, improving load speed and memory overhead for
individual instances. [ticket:1391]

this falls back to "expire" in any case since concat_op is not supported by the evaluator

Corrected missing stop in the ORM Tutorial. Fixes #1395.

Modified savepoint logic in mssql to ensure that it does not step on non-savepoint oriented routines. Savepoint support is still very experimental.

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