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]

Re-use func_defaults when generating wrapper functions. [ticket:1139]

- Renamed on_reconstitute to @reconstructor and reconstruct_instance
- Moved @reconstructor hooking to mapper
- Expanded reconstructor tests, docs

Tidy.

Ignore egg stuff.

adjust counts for 2.4 based on buildbot observation, remove 2.3 counts

dont rely upon AttributeError to test for None

- with 2.3 support dropped,
all usage of thread.get_ident() is removed, and replaced
with threading.local() usage.  this allows potentially
faster and safer thread local access.

added import for interfaces, otherwise tsa.interfaces is undef if the test is run standalone

- joins along a relation() from a mapped
class to a mapped subclass, where the mapped
subclass is configured with single table
inheritance, will include an
IN clause which limits the subtypes of the
joined class to those requsted, within the
ON clause of the join.  This takes effect for
eager load joins as well as query.join().
Note that in some scenarios the IN clause will
appear in the WHERE clause of the query
as well since this discrimination has multiple
trigger points.

- Improved the behavior of query.join()
when joining to joined-table inheritance
subclasses, using explicit join criteria
(i.e. not on a relation).

added info on named tuples

- When generating __init__, use a copy of the func_defaults, not a repr of them.

added col with no name example

- The composite() property type now supports
a __set_composite_values__() method on the composite
class which is required if the class represents
state using attribute names other than the
column's keynames; default-generated values now
get populated properly upon flush.  Also,
composites with attributes set to None compare
correctly.  [ticket:1132]

merged r5018 from 0.4 branch, but using contextual_connect() (will fix in 0.4 too)

comment

- cleaned up the attributes scan for reconstitute hooks
- added more careful check for "_should_exclude", guard against possible heisenbug activity

added unit tests for [ticket:1024]

added missing **kwargs

even better...

- Fixed @on_reconsitute hook for subclasses
which inherit from a base class.
[ticket:1129]

- Improved the determination of the FROM clause
when placing SQL expressions in the query()
list of entities.  In particular scalar subqueries
should not "leak" their inner FROM objects out
into the enclosing query.