- some clarifications and fixes to merge(instance, dont_load=True).
fixed bug where lazy loaders were getting disabled on returned instances.
Also, we currently do not support merging an instance which has uncommitted
changes on it, in the case that dont_load=True is used....this will
now raise an error.  This is due to complexities in merging the
"committed state" of the given instance to correctly correspond to the
newly copied instance.  Since the use case for dont_load=True is
caching, the given instances shouldn't have any uncommitted changes on them
anyway.

Typo fix

- clarified the error message which occurs when you try to update()
an instance with the same identity key as an instance already present
in the session.
- opened up the recursive checks in session.merge() a little bit

- fixed endless loop issue when using lazy="dynamic" on both
sides of a bi-directional relationship [ticket:872]

add a polymorphic get() test

doctest fixups

- added tests for [ticket:768]

- added op() operator to instrumented attributes; i.e.
User.name.op('ilike')('%somename%') [ticket:767]

- MSSQL anonymous labels for selection of functions made deterministic
- propagate correct **kwargs through mssql methods

repaired FB functions, [ticket:862]

Tests for mysql casts and a couple adjustments.

- Clarified use of python's Decimal

Migrated Connection.properties to Connection.info ('info' is the new standard name for user-writable property collections that came out of [ticket:573]).  'properties' is now an alias, will be removed in 0.5.

- added a little more checking for garbage-collection dereferences in
InstanceState.__cleanup() to reduce "gc ignored" errors on app
shutdown

added some ORDER BYs to appease the ever picky postgres

- PickleType will compare using `==` when set up with mutable=False,
and not the `is` operator.  To use `is` or any other comparator, send
in a custom comparison function using PickleType(comparator=my_custom_comparator).

test cases were not fully testing contains_eager() with regards to [ticket:777], fixed contains_eager() for more than one level deep

some wide zoomark ranges...

cut down a good deal of Join construction overhead

logging fixes

fixed both group-deferred attributes and expired attributes to not
blow away changes made on attributes before the load takes place

- oracle will now reflect "DATE" as an OracleDateTime column, not
OracleDate

- added awareness of schema name in oracle table_names() function,
fixes metadata.reflect(schema='someschema') [ticket:847]

removed is_expired() method since the meaning of "expired" is per-attribute now

oops, print statements...

typos

- session.refresh() and session.expire() now support an additional argument
"attribute_names", a list of individual attribute keynames to be refreshed
or expired, allowing partial reloads of attributes on an already-loaded
instance.
- finally simplified the behavior of deferred attributes, deferred polymorphic
load, session.refresh, session.expire, mapper._postfetch to all use a single
codepath through query._get(), which now supports a list of individual attribute names
to be refreshed.  the *one* exception still remaining is mapper._get_poly_select_loader(),
which may stay that way since its inline with an already processing load operation.
otherwise, query._get() is the single place that all "load this instance's row" operation
proceeds.
- cleanup all over the place

fixed further issues with row translation [ticket:868]

Restored Python 2.3 compatibility (in IdentitySet)

modified last commit; the eager loader only undefers columns from the primary mapped table.

- DeferredColumnLoader checks row for column, if present sends it to
ColumnLoader to create the row processor
- eager loaders ensure deferred foreign key cols are present in the primary list of columns (and secondary...).  because eager loading with LIMIT/OFFSET doesn't re-join to the parent table anymore this is now necessary. [ticket:864]

Removed some distractions, ala r3770.

Removed some distractions.

  - added having() method to Query, applies HAVING to the generated statement
    in the same way as filter() appends to the WHERE clause.

More column type __repr__ corrections.

AbstractType __repr__ robustification.

Remove usage of deprecated in_ syntax

- Pool listeners preserved on pool.recreate()
- Docstring rampage

Removed out of date identity map language (thanks, Jiten)

added self referential test

  - anonymous column expressions are automatically labeled.
    e.g. select([x* 5]) produces "SELECT x * 5 AS anon_1".
    This allows the labelname to be present in the cursor.description
    which can then be appropriately matched to result-column processing
    rules. (we can't reliably use positional tracking for result-column
    matches since text() expressions may represent multiple columns).

  - operator overloading is now controlled by TypeEngine objects - the
    one built-in operator overload so far is String types overloading
    '+' to be the string concatenation operator.
    User-defined types can also define their own operator overloading
    by overriding the adapt_operator(self, op) method.

  - untyped bind parameters on the right side of a binary expression
    will be assigned the type of the left side of the operation, to better
    enable the appropriate bind parameter processing to take effect
    [ticket:819]

- mysql float types now do an end run around the base class and respect precision=None and length=None
- Added the mysteriously missing mysql cast support
- Added mysql REAL synonym for schema generation

more searching for equiv columns

- fixed error where Query.add_column() would not accept a class-bound
attribute as an argument; Query also raises an error if an invalid
argument was sent to add_column() (at instances() time) [ticket:858]

- query doesn't throw an error if you use distinct() and an order_by()
containing UnaryExpressions (or other) together [ticket:848]

a tweak, still requiring test coverage, to add more "foreign key equivalents" to the equivalent_columns collection

more changes to traverse-and-clone; a particular element will only be cloned once and is
then re-used.  the FROM calculation of a Select normalizes the list of hide_froms against all
previous incarnations of each FROM clause, using a tag attached from cloned clause to
previous.

- identified some cases where Alias needs to be cloned; but still cant clone
when its an alias of a Table; added some test coverage for one particular
case from the doctests
- fixed "having" example in doctests, updated eager load example

updated zoomark test_1a_populate callcounts. if the calls keep being removed like this then soon there will be none left.

- fixed remainder of [ticket:853]
- bindparam 'shortname' is deprecated
- fixed testing.assert_compile() to actually generate bind param dict before asserting
- added bind param assertions to CRUDTest.test_update

  - <Engine|Connection>._execute_clauseelement becomes a public method
    Connectable.execute_clauseelement

  - fix to compiled bind parameters to not mistakenly populate None
    [ticket:853]

fixed the previous TLTransaction checkin

- fixed the close() method on Transaction when using strategy='threadlocal'

adjusted "blank out primary key" rule to check for "allow_null_pks" on target mapper.  this was revealed by
recent attributes.py change in r3695 that causes a value of "None" to register as part of the attribute history's
added_items() collection (i.e. since AttributeHistory compares against NO_VALUE instead of None).

  - fixed very hard-to-reproduce issue where by the FROM clause of Query
    could get polluted by certain generative calls [ticket:852]

fixed/added coverage for list extension; [ticket:855]

Added missing InternalError exception wrapper [ticket:854]

Create a storage field for arbitrary info on tables/columns; ticket #573

Added note about EXT_CONTINUE to 3.x -> 4.x migration guide

Migrated maxdb behavioral assumptions from unsupported to fails_on

Added testing.fails_on('db') failure-asserter.

- figured out a way to get previous oracle behavior back.  the ROWID thing
is still a pretty thorny issue.

- adjustments to oracle ROWID logic...recent oid changes mean we have to
use "rowid" against the select itself (i.e. its just...'rowid', no table name).
seems to work OK but not sure if issues will arise
- fixes to oracle bind param stuff to account for recent removal of ClauseParameters object.

- oid_column proxies more intelligently off of Select, CompoundSelect - fixes platform-affected bugs in missing the correct "oid" column
- locate_all_froms() is expensive; added an attribute-level cache for it
- put a huge warning on all select.append_XXX() methods stating that derived collections like locate_all_froms() may become invalid if
already initialized

Whitespace cleanup

- base_columns on ColumnElement becomes a list; as usual, because columns in CompoundSelects
may extend from more than one root column.
- keys_ok argument from corresponding_column() removed.  no more name-based matching of columns anywhere.
- DictDecorator is gone.  all row translators provided by orm.util.create_row_adapter().  Mapper
and contains_alias() cache the adapters on target mapper to avoid re-computation of adapters.
- create_row_adapter() accepts an "equivalent_columns" map as produced by Mapper, so that
row adapters can take join conditions into account (as usual again, to help with the CompoundSelects
produced by polymorphic_union).
- simplified TableSingleton to just provide lookup; moved all initialization into Table.
- the "properties" accessor on Mapper is removed; it now throws an informative
exception explaining the usage of mapper.get_property() and
mapper.iterate_properties

- SHOW CREATE TABLE output is slightly different if msyql is in ANSI mode

- rewrote and simplified the system used to "target" columns across
selectable expressions.  On the SQL side this is represented by the
"corresponding_column()" method. This method is used heavily by the ORM
to "adapt" elements of an expression to similar, aliased expressions,
as well as to target result set columns originally bound to a
table or selectable to an aliased, "corresponding" expression.  The new
rewrite features completely consistent and accurate behavior.
- the "orig_set" and "distance" elements as well as all associated
fanfare are gone (hooray !)
- columns now have an optional "proxies" list which is a list of all
columns they are a "proxy" for; only CompoundSelect cols proxy more than one column
(just like before).  set operations are used to determine lineage.
- CompoundSelects (i.e. unions) only create one public-facing proxy column per
column name.  primary key collections come out with just one column per embedded
PK column.
- made the alias used by eager load limited subquery anonymous.

  - func. objects can be pickled/unpickled [ticket:844]

- eager loading with LIMIT/OFFSET applied no longer adds the primary
table joined to a limited subquery of itself; the eager loads now
join directly to the subquery which also provides the primary table's
columns to the result set.  This eliminates a JOIN from all eager loads
with LIMIT/OFFSET.  [ticket:843]

- rewritten ClauseAdapter merged from the eager_minus_join branch; this is a much simpler
and "correct" version which will copy all elements exactly once, except for those which were
replaced with target elements.  It also can match a wider variety of target elements including
joins and selects on identity alone.

Added a profiled benchmark for orm attribute modification & flush

- Swap operator.eq for lambda x,y: x==y
- Some docstring re-formatting

Formatting for 0.4.1

Added some more notes for maxdb

- Removed equality, truth and hash() testing of mapped instances. Mapped
  classes can now implement arbitrary __eq__ and friends. [ticket:676]

- removed "name" attribute from FromClause, Join, Select, CompoundSelect.  its needless
and led to some very strange anonymous label names
- removed what was apparently cruft in some column-targeting code

added small clarification on single-table inheritance mapper def

doc updates for save_on_init=False, merge(...dont_save=True)

- extra merge test
- merge with dont_load also propagates _state.modified

- merge() includes a keyword argument "dont_load=True".  setting this flag will cause
the merge operation to not load any data from the database in response to incoming
detached objects, and will accept the incoming detached object as though it were
already present in that session.  Use this to merge detached objects from external
caching systems into the session.

More improvements to testlib's mapper decorator

Tweaks for assert_unordered_result

Added AssertMixin.assert_unordered_result

- session checks more carefully when determining "object X already in another session";
e.g. if you pickle a series of objects and unpickle (i.e. as in a Pylons HTTP session
or similar), they can go into a new session without any conflict
- added stricter checks around session.delete() similar to update()
- shored up some old "validate" stuff in session/uow

Added rowset() testing helper.

Fixed truth-evaluation of mapped objects (part of [ticket:676]

- merged factor_down_bindparams branch.
- removed ClauseParameters object; compiled.params returns a regular dictionary
  now, as well as result.last_inserted_params()/last_updated_params().
- various code trimming, method removals.

Added command line options to add tripwires for __hash__, __eq__ and __nonzero__ on mapped classes.

- A more efficient IdentitySet

- split ScalarInstrumentedAttribute into a "scalar" and an "object" version.
The "object" version loads the existing value on set/del, fires events,
 and handles trackparent operations; the "scalar" version does not.
- column loaders now use the "scalar" version of InstrumentedAttribute, so that
event handlers etc. don't fire off for regular column attribute operations.
- some adjustments to AttributeHistory to work properly for non-loaded attributes
- deferred column attributes no longer trigger a load operation when the
attribute is assigned to.  in those cases, the newly assigned
value will be present in the flushes' UPDATE statement unconditionally.

dont call up new session unless save_on_init

- also added proxying of save_or_update to scoped sessions.
- session.update() raises an error when updating an instance that is already in the session with a different identity
- adjusted zoomarks lower limits so I can get a nice clean run

added REAL to reflection list

Added proxying of __contains__ and __iter__ methods for scoped sessions

Fixup sp_columns call

Fixed a truncation error when re-assigning a subset of a collection
(obj.relation = obj.relation[1:]) [ticket:834]

Added util.IdentitySet to support [ticket:676] and [ticket:834]

Formatting tweaks.

- Removed unused util.hash()
- Fixed __hash__ for association proxy collections