- 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

- added assert_raises() to TestBase class
- session.refresh() and session.expire() raise an error when
called on instances which are not persistent within the session
- session._validate_persistent() properly raises an error for false check

check the isinsert/isupdate flags before calling __process_defaults

- adjusted generative.py test for revised error message
- mapper with non_primary asserts primary mapper already created
- added any()/instance compare test to query

Import fixup & trailing whitespace

- Synonyms riding on top of existing descriptors are now full proxies
  to those descriptors.

- constraint constructor docstring fiesta

- More docs for r4223

- Tweaked error messaging for unbound DDL().execute()

- Gave DDL() statements the same .bind treatment as the DML ones in r4220

- whitespace/docstring/linewrap freakout

- Updated exception messaging for r4220

- added "bind" keyword argument to insert(), update(), delete();
.bind property is settable on those as well as select().

unit test for mutable PGArray, thanks to AlexB !!!

check for None

- postgres PGArray is a "mutable" type by default;
when used with the ORM, mutable-style equality/
copy-on-write techniques are used to test for changes.

fixed negated self-referential m2m contains(), [ticket:987]

- fixed bug which was preventing UNIONS from being cloneable,
[ticket:986]

fix markdown bug

- repaired behavior of == and != operators at the relation()
level when compared against NULL for one-to-one and other
relations [ticket:985]

(very) minor speed optimization to ResultProxy fetchall & fetchmany methods

added dispose() for StaticPool

fix maddening ReST bug

document with_polymorphic()

- Raise a friendly error when assigning an unmapped something (like a string) to a scalar-object attribute

- state.commit() and state.commit_all() now reconcile the current dict against expired_attributes
and unset the expired flag for those attributes.  This is partially so that attributes are not
needlessly marked as expired after a two-phase inheritance load.
- fixed bug which was introduced in 0.4.3, whereby loading an
already-persistent instance mapped with joined table inheritance
would trigger a useless "secondary" load from its joined
table, when using the default "select" polymorphic_fetch.
This was due to attributes being marked as expired
during its first load and not getting unmarked from the
previous "secondary" load.  Attributes are now unexpired
based on presence in __dict__ after any load or commit
operation succeeds.

add note about global metadata removed [ticket:983]

- fixed bug whereby session.expire() attributes were not
loading on an polymorphically-mapped instance mapped
by a select_table mapper.

- added query.with_polymorphic() - specifies a list
of classes which descend from the base class, which will
be added to the FROM clause of the query.  Allows subclasses
to be used within filter() criterion as well as eagerly loads
the attributes of those subclasses.

- deprecated Query methods apply_sum(), apply_max(), apply_min(),
apply_avg().  Better methodologies are coming....

- setting the relation()-level order by to a column in the
many-to-many "secondary" table will now work with eager
loading, previously the "order by" wasn't aliased against
the secondary table's alias.

some cleanup of TypeDecorator, moved PickleType / Interval to the newer style for readability

- postgres TIMESTAMP renders correctly [ticket:981]

- implemented two-phase API for "threadlocal" engine,
via engine.begin_twophase(), engine.prepare()
[ticket:936]

- added exception wrapping/reconnect support to result set
fetching.  Reconnect works for those databases that
raise a catchable data error during results
(i.e. doesn't work on MySQL) [ticket:978]

silliness reduction

- Invalid SQLite connection URLs now raise an error.

C-u 66 C-x f M-q

- the value of a bindparam() can be a callable, in which
case it's evaluated at statement execution time to
get the value.
- expressions used in filter(), filter_by() and others,
when they make usage of a clause generated from a
relation using the identity of a child object
(e.g. filter(Parent.child==<somechild>)), evaluate
the actual primary key value of <somechild> at
execution time so that the autoflush step of the
Query can complete, thereby populating the PK value
of <somechild> in the case that <somechild> was
pending.
- cleanup of attributes.get_committed_value() to never return
the NO_VALUE value; evaluates to None

- Converted MAGICCOOKIE=object() to a little symbol implementation to ease object inspection and debugging

er, ok, dont do that (reversed last change).  PG relies upon _register_clean for
new PK switch even if no SQL is emitted.

dont treat "listonly" objects as newly clean

- preventive code against a potential lost-reference
bug in flush()

- added a new "higher level" operator called "of_type()" -
used in join() as well as with any() and has(), qualifies
the subclass which will be used in filter criterion,
e.g.:

query.filter(Company.employees.of_type(Engineer).
  any(Engineer.name=='foo')),

query.join(Company.employees.of_type(Engineer)).
  filter(Engineer.name=='foo')

- fixed potential generative bug when the same Query was
used to generate multiple Query objects using join().

- can again create aliases of selects against textual
FROM clauses, [ticket:975]

- modernized cascade.py tests
- your cries have been heard:  removing a pending item
from an attribute or collection with delete-orphan
expunges the item from the session; no FlushError is raised.
Note that if you session.save()'ed the pending item
explicitly, the attribute/collection removal still knocks
it out.

get basic compilation working for [ticket:972]

- any(), has(), contains(), attribute level == and != now
work properly with self-referential relations - the clause
inside the EXISTS is aliased on the "remote" side to
distinguish it from the parent table.

- remove some old cruft
- deprecate ancient engine_descriptors() method

Bump.

fixing recent schema.py changes to work with oracle 'owner' attribute

- comment typo

- Made testlib's --unhashable and r3935's set changes play nice
- A bonus overhead reduction for IdentitySet instances

- Corrected __eq__ pragma drift.

Restore 2.3 compat for the sharding test

fixed (still uncovered) incorrect variable name...

- Fixed a couple pyflakes, cleaned up imports & whitespace

MSSQL now compiles func.now() to CURRENT_TIMESTAMP

- fixed bug in result proxy where anonymously generated
column labels would not be accessible using their straight
string name

Added EXEC to MSSQL _is_select regexp; should now detect row-returning stored procedures
Added experimental implementation of limit/offset using row_number()

a TODO comment

0.4.3 edits

- fixed bug introduced in r4070 where union() and other compound selects would not get
an OID column if it only contained one selectable element, due to missing return in _proxy_column()
- visit_column() calls itself to render a primary key col being used as the interpretation of the oid col instead of relying upon broken partial logic

add pk cols to assocaition table

- Added two new vertical dict mapping examples.

- added expire_all() method to Session.  Calls expire()
for all persistent instances.  This is handy in conjunction
with .....

- instances which have been partially or fully expired
will have their expired attributes populated during a regular
Query operation which affects those objects, preventing
a needless second SQL statement for each instance.

- Fixed .get(<int>) of a String PK (exposed by pg 8.3)

- updated the naming scheme of the base test classes in test/testlib/testing.py;
tests extend from either TestBase or ORMTest, using additional mixins for
special assertion methods as needed

- Table columns and constraints can be overridden on a
an existing table (such as a table that was already
reflected) using the 'useexisting=True' flag, which now
takes into account the arguments passed along with it.
- fixed one element of [ticket:910]
- refactored reflection test

- Better error messaging on failed collection bulk-assignments

- Note about future CollectionAttributeImp.collection_intrface removal + whitespace cleanup.

- Determine the basic collection interface dynamically when adapting a collection to an interable

added info on foreign_keys attribute

- lazy loader can now handle a join condition where the "bound"
column (i.e. the one that gets the parent id sent as a bind
parameter) appears more than once in the join condition.
Specifically this allows the common task of a relation()
which contains a parent-correlated subquery, such as "select
only the most recent child item". [ticket:946]
- col_is_part_of_mappings made more strict, seems to be OK
with tests
- memusage will dump out the size list in an assertion fail

heisenbug in aisle 3

(when db.dispose is called in unitofwork test with sqlite, the first test that runs in memusage grows by two gc'ed objects on every iteration; then the problem vanishes.  doesnt matter what test runs in memusage.  doing a dispose() in memusage solves the problem also.  screwing wiht the mechanics of engine.dispose() only fix it when both the pool.dispose() *and* the pool.ressurect() are disabled.  its just a subtle python/pysqlite bug afaict)

- added generative where(<criterion>) method to delete()
and update() constructs which return a new object with
criterion joined to existing criterion via AND, just
like select().where().
- compile assertions use assertEquals()

- Added deferrability support to constraints

- psycopg2 can raise un-str()able exceptions; don't croak when trying to log them

Fix: deletes with schemas on MSSQL 2000 [ticket:967]

test for session close efficiency

Fix some mssql unit tests

Strip schema from access tables

Avoid using common keywords as field names: the test executes literal selects

check for unicode first before encoding

unit-of-work flush didn't close the failed transaction when the session was not in a transaction and commiting the transaction failed.

- Some more reST docstring corrections

- clean up the print version of the docs a bit [ticket:745]