fixed test for #1175

- fix outerjoin, add order_by for DB variance

Change in #1165 tests to prevent MySQL from choking on a varchar without a length.

Corrects issue where engine.execute raised exception when given empty list. Fixes #1175.

- using contains_eager() against an alias combined with an overall query alias repaired - the
contains_eager adapter wraps the query adapter, not vice versa.  Test coverage added.
- contains_eager() will now add columns into the "primary" column collection within Query._compile_context(), instead
of the "secondary" collection.  This allows those columns to get wrapped within the subquery generated
by limit/offset in conjunction with an ORM-generated eager join.
Eager strategy also picks up on context.adapter in this case to deliver the columns during result load.
contains_eager() is now compatible with the subquery generated by a regular eager load
with limit/offset. [ticket:1180]

- added a few more assertions for [ticket:1165]
- removed non-2.5 partial.keywords, partial.name, etc., not sure what those are getting us here

Didnt think about <2.5. When will I learn.

Allowed column types to be callables. Fixes #1165.

- Adjustment to Session's post-flush accounting of newly
"clean" objects to better protect against operating on
objects as they're asynchronously gc'ed. [ticket:1182]

- identity_map._mutable_attrs is a plain dict since we manage weakref removal explicitly
- call list() around iteration of _mutable_attrs to guard against async gc.collect() while check_modified() is running

the @property / __slots__ fairy pays a visit

Issue a better error message when someone decides to meddle with the active transaction from within a context manager.

Fixed session.transaction.commit() on a autocommit=False session not starting a new transaction.
Moved starting a new transaction in case of previous closing into SessionTransaction.

- session.execute() will execute a Sequence object passed to
  it (regression from 0.4).
- Removed the "raiseerror" keyword argument from object_mapper()
  and class_mapper().  These functions raise in all cases
  if the given class/instance is not mapped.
- Refined ExtensionCarrier to be itself a dict, removed
'methods' accessor
- moved identity_key tests to test/orm/utils.py
- some docstrings

- Fixed up slices on Query (i.e. query[x:y]) to work properly
for zero length slices, slices with None on either end.
[ticket:1177]

Tidy.

fixed custom TypeEngine example

Fixed mysql TEMPORARY table reflection.

- Fixed shared state bug interfering with ScopedSession.mapper's
  ability to apply default __init__ implementations on object
  subclasses.

re-enabled memusage and connect tests.

Added query_cls= override to scoped_session's query_property

- fixed RLock-related bug in mapper which could deadlock
upon reentrant mapper compile() calls, something that
occurs when using declarative constructs inside of
ForeignKey objects.

random cleanup

genericized the relationship between bind_processor() and _bind_processor() a little more

- Overhauled SQLite date/time bind/result processing
to use regular expressions and format strings, rather
than strptime/strftime, to generically support
pre-1900 dates, dates with microseconds.  [ticket:968]

the wisdom of SQLite accepting strings for columns with the INT type....priceless

fix up element sorting in declarative

Get a bit more speed into the new _sort_states function. It's probably possible
to get even more speed by getting rid of the decorator and call the method
directly, but it makes for slightly less readable code so I won't do it since I
don't know whether this code is speed-critical or not.

- Fixed bug involving read/write relation()s that
contain literal or other non-column expressions
within their primaryjoin condition equated
to a foreign key column.
- fixed UnmappedColumnError exception raise to not assume it was passed a column

un-stupified insert/update/delete sorting

more failing cases

"nested sets" example.  needs work.

- "non-batch" mode in mapper(), a feature which allows
mapper extension methods to be called as each instance
is updated/inserted, now honors the insert order
of the objects given.
- added some tests, some commented out, involving [ticket:1171]

- version bump
- turned properties in sql/expressions.py to @property
- column.in_(someselect) can now be used as
a columns-clause expression without the subquery
bleeding into the FROM clause [ticket:1074]

added gc.collect() for pypy/jython compat, [ticket:1076]

- annual unitofwork cleanup
- moved conversion of cyclical sort to UOWTask structure to be non-recursive
- reduced some verbosity
- rationale for the "tree" sort clarified
- would love to flatten all of uow topological sorting, sorting within mapper._save_obj() into a single sort someday

- 0.5.0rc1
- removed unneeded grouping from BooleanClauseList, generated needless parens

- Added scalar() and value() methods to Query, each return a
single scalar value.  scalar() takes no arguments and is
roughly equivalent to first()[0], value()
takes a single column expression and is roughly equivalent to
values(expr).next()[0].

Note to self: save buffers before committing.

Added Query.scalar() sugar method, eases migration from old query.sum() methods.  Needs tests.

- the function func.utc_timestamp() compiles to UTC_TIMESTAMP, without
the parenthesis, which seem to get in the way when using in
conjunction with executemany().

return type of exists() is boolean, duh

- Bind params now subclass ColumnElement which allows them to be
selectable by orm.query (they already had most ColumnElement
semantics).

- Added select_from() method to exists() construct, which becomes
more and more compatible with a regular select().

- Bind parameters/literals given a True/False value will detect
their type as Boolean

Fix bug with MSSQL reflecting and schemas

- The exists() construct won't "export" its contained list
of elements as FROM clauses, allowing them to be used more
effectively in the columns clause of a SELECT.

- and_() and or_() now generate a ColumnElement, allowing
boolean expressions as result columns, i.e.
select([and_(1, 0)]).  [ticket:798]

reverted inheritance tweak which fails tests on non-sqlite

- Added func.min(), func.max(), func.sum() as "generic functions",
which basically allows for their return type to be determined
automatically.  Helps with dates on SQLite, decimal types,
others. [ticket:1160]

- added decimal.Decimal as an "auto-detect" type; bind parameters
and generic functions will set their type to Numeric when a
Decimal is used.

- Removed conflicting `contains()` operator from
`InstrumentedAttribute` which didn't accept `escape` kwaarg
[ticket:1153].

- Dropped 0.3-compatibility for user defined types
(convert_result_value, convert_bind_param).

- query.order_by().get() silently drops the "ORDER BY" from
the query issued by GET but does not raise an exception.

- rearranged delete() so that the object is attached before
cascades fire off [ticket:5058]
- after_attach() only fires if the object was not previously attached

synchronize inherited does not need to be called for the full mapper hierarchy

- Fixed exception throw which would occur when string-based
primaryjoin condition was used in conjunction with backref.

allow the no_criterion call in _get() to copy the method name thorugh

- Fixed bug whereby mapper couldn't initialize if a composite
primary key referenced another table that was not defined
yet [ticket:1161]

 added BFILE to reflected type names [ticket:1121]

correct extra space in SQL assertions

 - has_sequence() now takes the current "schema" argument into
      account [ticket:1155]

 - limit/offset no longer uses ROW NUMBER OVER to limit rows,
      and instead uses subqueries in conjunction with a special
      Oracle optimization comment.  Allows LIMIT/OFFSET to work
      in conjunction with DISTINCT. [ticket:536]

Make Query.update and Query.delete return the amount of rows matched

correction

- column_property(), composite_property(), and relation() now
accept a single or list of AttributeExtensions using the
"extension" keyword argument.
- Added a Validator AttributeExtension, as well as a
@validates decorator which is used in a similar fashion
as @reconstructor, and marks a method as validating
one or more mapped attributes.
- removed validate_attributes example, the new methodology replaces it

- AttributeListener has been refined such that the event
is fired before the mutation actually occurs.  Addtionally,
the append() and set() methods must now return the given value,
which is used as the value to be used in the mutation operation.
This allows creation of validating AttributeListeners which
raise before the action actually occurs, and which can change
the given value into something else before its used.
A new example "validate_attributes.py" shows one such recipe
for doing this.   AttributeListener helper functions are
also on the way.

- Fixed custom instrumentation bug whereby get_instance_dict()
was not called for newly constructed instances not loaded
by the ORM.

- broke pool tests out into QueuePoolTest/SingletonThreadPoolTest
- added test for r5061/r5062 [ticket:1157]

recheck the dirty list if extensions are present

- The "extension" argument to Session and others can now
optionally be a list, supporting events sent to multiple
SessionExtension instances.  Session places SessionExtensions
in Session.extensions.

- add an example illustrating attribute event reception.

check extensions each time; user-defined code will be appending to "extensions" after the AttributeImpl has been constructed

- starargs_as_list was not actually issuing SAPendingDeprecationWarning, fixed
- implemented code cleanup from [ticket:1152] but not including using the decorators module

- Fixed bug whereby deferred() columns with a group in conjunction
with an otherwise unrelated synonym() would produce
an AttributeError during deferred load.

Corrected typo in the mapper docs. Fixes #1159.

Type processors get a dialect, not an engine...

ugh...try again

critical fix to r5028 repairs SingleThreadPool to return a connection in case one had been removed via cleanup()

- expire/fetch strategies are now default for Query.update/Query.delete.
- added API docs for Query.update/Query.delete

- Fixed bug whereby changing a primary key attribute on an
entity where the attribute's previous value had been expired
would produce an error upon flush(). [ticket:1151]

- Session.delete() adds the given object to the session if
not already present.  This was a regression bug from 0.4
[ticket:1150]

- Added MSMediumInteger type [ticket:1146].

- logging scale-back; the echo_uow flag on Session is deprecated, and unit of work logging is now
class level like all the other logging.
- trimmed back the logging API, centralized class_logger() as the single point of configuration for
logging, removed per-instance logging checks from ORM.
- Engine and Pool logging remain at the instance level.  The modulus of "instance ids" has been upped
to 65535.  I'd like to remove the modulus altogether but I do see a couple of users each month
calling create_engine() on a per-request basis, an incorrect practice but I'd rather their applications
don't just run out of memory.

- The 'length' argument to all Numeric types has been renamed
to 'scale'.  'length' is deprecated and is still accepted
with a warning. [ticket:827]
- The 'length' argument to MSInteger, MSBigInteger, MSTinyInteger,
MSSmallInteger and MSYear has been renamed to 'display_width'.
[ticket:827]
- mysql._Numeric now consumes 'unsigned' and 'zerofill' from
the given kw, so that the same kw can be passed along to Numeric
and allow the 'length' deprecation logic to still take effect
- added testlib.engines.all_dialects() to return a dialect for
every db module
- informix added to sqlalchemy.databases.__all__.  Since other
"experimental" dbs like access and sybase are there, informix
should be as well.

- fixed tearDown to reverse sorted table list

- attributes now has an "active_history" flag.  This flag indicates that when new value is set or the existing value is deleted, we absolutely need the previous value to be present, including if it requires hitting a lazy loader.  Since somewhere around 0.4 we had not been loading the previous value as a performance optimization.
- the flag is set by a ColumnLoader which contains a primary key column.  This allows the mapper to have an accurate record of a primary key column when _save_obj() performs an UPDATE.
- the definition of who gets "active_history" may be expanded to include ForeignKey and any columns participating in a primaryjoin/seconddary join, so that lazyloaders can execute correctly on an expired object with pending changes to those attributes.
- expire-on-commit is why this is becoming a more important issue as of late
- fixes [ticket:1151], but unit tests, CHANGES note is pending

- column_property() and synonym() both accept comparator_factory argument, allowing
custom comparison functionality
- made the mapper's checks for user-based descriptors when defining synonym or comparable property
stronger, such that a synonym can be used with declarative without having a user-based descriptor

- Another old-style mixin fix and an explicit mapper() test for it.

- Fix occurences of Class.c.column_name
- Fix a few typos/mistakes
- removed trailing whitespaces
- tried to achieve a more consistent syntax for spaces in properties
  declaration

- fixed a bug in declarative test which was looking for old version of history
- Added "sorted_tables" accessor to MetaData, which returns
Table objects sorted in order of dependency as a list.
This deprecates the MetaData.table_iterator() method.
The "reverse=False" keyword argument has also been
removed from util.sort_tables(); use the Python
'reversed' function to reverse the results.
[ticket:1033]

catch AttributeError in case thread local storage was not configured

attributes.get_history now reports some zero-length slots as the empty tuple rather than an empty list. nice speed boost and memory reduction.

hack tweak: exc.NO_STATE is a tuple.

more ORM @decorator fliparoo

- The before_flush() hook on SessionExtension takes place
before the list of new/dirty/deleted is calculated for the
final time, allowing routines within before_flush() to
further change the state of the Session before the flush
proceeds.   [ticket:1128]

- Reentrant calls to flush() raise an error.  This also
serves as a rudimentary, but not foolproof, check against
concurrent calls to Session.flush().

temporary check for unmapped class, until [ticket:1142] is resolved

- fixed primary key update for many-to-many collections
where the collection had not been loaded yet
[ticket:1127]

- class.someprop.in_() raises NotImplementedError pending
the implementation of "in_" for relation [ticket:1140]

Applied .append(x, **kw) removal patch from [ticket:1124] and general cleanup.

- Mock engines take on the .name of their dialect. [ticket:1123]

  Slightly backward incompatible: the .name is a read-only property.
  The test suite was assigning .name = 'mock'; this no longer works.

- Don't choke when instrumenting a class with an old-style mixin. [ticket:1078]

removing this example until further notice (append_result() not an easy road to travel)

- Ignore old-style classes when building inheritance graphs. [ticket:1078]