fixed a huge bug in the C version of the unicode processor

- Further fixes for the mysql-connector dialect.  [ticket:1668]

I'm seeing lower numbers from the objselectspeed.py test, so bumping down the lower bounds here.

linking some API elements.  this is a long job that I don't know how to speed up

repair all doctests

- query.one() no longer applies LIMIT to the query, this to
ensure that it fully counts all object identities present
in the result, even in the case where joins may conceal
multiple identities for two or more rows.  As a bonus,
one() can now also be called with a query that issued
from_statement() to start with since it no longer modifies
the query.  [ticket:1688]

add a note

try to clarify intent some more

- Added an optional C extension to speed up the sql layer by
  reimplementing the highest impact functions.
  The actual speedups will depend heavily on your DBAPI and
  the mix of datatypes used in your tables, and can vary from
  a 50% improvement to more than 200%. It also provides a modest
  (~20%) indirect improvement to ORM speed for large queries.
  Note that it is *not* built/installed by default.
  See README for installation instructions.

- The most common result processors conversion function were
  moved to the new "processors" module.  Dialect authors are
  encouraged to use those functions whenever they correspond
  to their needs instead of implementing custom ones.

- Documentation clarification for query.delete()
[ticket:1689]

- reduced a bit of overhead in attribute expiration, particularly
the version called by column loaders on an incomplete row (i.e.
joined table inheritance).  there are more dramatic changes
that can be made here but this one is conservative so far
as far as how much we're altering how InstanceState tracks
"expired" attributes.

misc cleanups in tests (courtesy of Michael Bayer's revisiting of my
patch)

- For those who might use debug logging on
sqlalchemy.orm.strategies, most logging calls during row
loading have been removed.   These were never very helpful
and cluttered up the code.

- Some internal streamlining of object loading grants a
small speedup for large results, estimates are around
10-15%.

commit a note about 2to3

- Improved the installation/test setup regarding Python 3,
now that Distribute runs on Py3k.   distribute_setup.py
is now included.  See README.py3k for Python 3 installation/
testing instructions.

- Changed the beaker cache example a bit to have a separate
RelationCache option for lazyload caching.  This object
does a lookup among any number of potential attributes
more efficiently by grouping several into a common structure.
Both FromCache and RelationCache are simpler individually.

adding more mapper sections nobody will ever see !

formatting

since I just got confused over my own serializer module, clarify its purpose

this is beta2

  - Made sqlalchemy.sql.expressions.Executable part of public
    API, used for any expression construct that can be sent to
    execute().  FunctionElement now inherits Executable so that
    it gains execution_options(), which are also propagated
    to the select() that's generated within execute().
    Executable in turn subclasses _Generative which marks
    any ClauseElement that supports the @_generative
    decorator - these may also become "public" for the benefit
    of the compiler extension at some point.

- The type/expression system now does a more complete job
of determining the return type from an expression
as well as the adaptation of the Python operator into
a SQL operator, based on the full left/right/operator
of the given expression.  In particular
the date/time/interval system created for Postgresql
EXTRACT in [ticket:1647] has now been generalized into
the type system.   The previous behavior which often
occured of an expression "column + literal" forcing
the type of "literal" to be the same as that of "column"
will now usually not occur - the type of
"literal" is first derived from the Python type of the
literal, assuming standard native Python types + date
types, before falling back to that of the known type
on the other side of the expression.  Also part
of [ticket:1683].

slightly simplify/optimize string/unicode bind processor

   - Added "native_datetime=True" flag to create_engine().
     This will cause the DATE and TIMESTAMP types to skip
     all bind parameter and result row processing, under
     the assumption that PARSE_DECLTYPES has been enabled
     on the connection.  Note that this is not entirely
     compatible with the "func.current_date()", which
     will be returned as a string. [ticket:1685]

Fixed bug in session.merge() blocking dict-like collections from merging.

Fix mysql reflection of TINYINT(1) UNSIGNED columns.

- Restored the keys() method to ResultProxy.

- Fixed reflection bug whereby when COLLATE was present,
nullable flag and server defaults would not be reflected.
[ticket:1655]

Fix instance.__eq__() regression in orm attributes.

Link to the maintained version of the kinterbasdb driver, fixes #1677

- Query called in the context of an expression will render
disambiguating labels in all cases.    Note that this does
not apply to the existing .statement and .subquery()
accessor/method, which still honors the .with_labels()
setting that defaults to False.

- Query.union() retains disambiguating labels within the
returned statement, thus avoiding various SQL composition
errors which can result from column name conflicts.
[ticket:1676]

fix up formatting, add OurSQL

- Now uses sqlalchemy.orm.exc.DetachedInstanceError when an
attribute load or refresh action fails due to object
being detached from any Session.   UnboundExecutionError
is specific to engines bound to sessions and statements.

add sql_compiler property to all Compiled subclasses for convenience

dont reference self.statement during compilation

- FunctionElement subclasses are now directly executable the
same way any func.foo() construct is, with automatic
SELECT being applied when passed to execute().

- The "type" and "bind" keyword arguments of a func.foo()
construct are now local to "func." constructs and are
not part of the FunctionElement base class, allowing
a "type" to be handled in a custom constructor or
class-level variable.

add a note about type for ColumnElement

fix

- Re-established initial support for pymssql.

- Slight improvement to the fix for [ticket:1362] to not issue
needless updates of the primary key column during a so-called
"row switch" operation, i.e. add + delete of two objects
with the same PK.

- Fixed bug in session.rollback() which involved not removing
formerly "pending" objects from the session before
re-integrating "deleted" objects, typically occured with
natural primary keys. If there was a primary key conflict
between them, the attach of the deleted would fail
internally. The formerly "pending" objects are now expunged
first. [ticket:1674]

- Added math negation operator support, -x.

a big, unmissable, green box describing the caveats of String() and Sequence.

bug #1 , wrong 0.5 version mentioned !

- official name
- remove the switch readme

the order of rollback()s wasn't correct.  slightly disturbing as the test usually passed,
began failing on PG as of somewhat unrelated commit r6705, and only when the full test/engine series
of tests were run.  very heisenbuggy. may want to add tests to assert that TLEngine is enforcing
nesting even with subtransactions.

- Primary key values can now be changed on a joined-table inheritance
object, and ON UPDATE CASCADE will be taken into account when
the flush happens.  Set the new "passive_updates" flag to False
on mapper() when using SQLite or MySQL/MyISAM. [ticket:1362]

- flush() now detects when a primary key column was updated by
an ON UPDATE CASCADE operation from another primary key, and
can then locate the row for a subsequent UPDATE on the new PK
value.  This occurs when a relation() is there to establish
the relationship as well as passive_updates=True.  [ticket:1671]

formatting tweak

add 0.5.9 note for [ticket:1661]

- added a failing-so-far test for #1671

yikes entirely wrong option name here

- use_ansi=False won't leak into the FROM/WHERE clause of
a statement that's selecting from a subquery that also
uses JOIN/OUTERJOIN.

- the "save-update" cascade will now cascade the pending *removed*
values from a scalar or collection attribute into the new session
during an add() operation.  This so that the flush() operation
will also delete or modify rows of those disconnected items.

- the "connection" argument from engine.transaction() and
engine.run_callable() is removed - Connection itself
now has those methods.   All four methods accept
*args and **kwargs which are passed to the given callable,
as well as the operating connection.

oursql doesn't need the warnings propagate flag

for string deferred evals, don't return the underlying Column, rely upon the original propcomparator to do what it wants.
reduces duplication of the "columns[0]" rule and removes potentially surprise behavior from the eval

fix the kwargs scoping.  mysteriously was affecting pool gcing

- inline some code and turn some instance-level defaults into class level

- the "autocommit" flag on select() and text() as well
      as select().autocommit() are deprecated - now call
      .execution_options(autocommit=True) on either of those
      constructs, also available directly on Connection and orm.Query.

- make frozendict serializable
- serialize tests use HIGHEST_PROTOCOL

against is optional

- allow exists(s.as_scalar()) to work

add an informative error msg for non-collection passed to select()

Fix #1663: the whitespace after DEFAULT may start with a newline

missing import, forcefully compile the expression to str

oracle compat

Binary -> LargeBinary

- Added a tuple_() construct, allows sets of expressions
to be compared to another set, typically with IN against
composite primary keys or similar.  Also accepts an
IN with multiple columns.   The "scalar select can
have only one column" error message is removed - will
rely upon the database to report problems with
col mismatch.

added a test to ensure the concrete example in the docs works

handle the new CursorFairy __setattr__

fricking typo

remove my comment.  still wish this could be done in a cleaner way tho

- union(), intersect(), except() and other "compound" types
of statements have more consistent behavior w.r.t.
parenthesizing.   Each compound element embedded within
another will now be grouped with parenthesis - previously,
the first compound element in the list would not be grouped,
as SQLite doesn't like a statement to start with
parenthesis.   However, Postgresql in particular has
precedence rules regarding INTERSECT, and it is
more consistent for parenthesis to be applied equally
to all sub-elements.   So now, the workaround for SQLite
is also what the workaround for PG was previously -
when nesting compound elements, the first one usually needs
".alias().select()" called on it to wrap it inside
of a subquery.  [ticket:1665]

revert r6686 and adjust the stacklevel of test_notsane_warning's SAWarning so
it can force it to be emitted

- Connection has execution_options(), generative method
which accepts keywords that affect how the statement
is executed w.r.t. the DBAPI.   Currently supports
"stream_results", causes psycopg2 to use a server
side cursor for that statement.   Can also be set
upon select() and text() constructs directly as well
as ORM Query().

query

test_notsane_working needs to run first for dialects that don't
supports_sane_rowcount so the other VersioningTests don't ignore the warning it
expects (that ignore lasts forever)

not ready to put execution_options in the text()/select() constructors yet

- move "should_autocommit" to a deferred method.   connection wont call it if a transaction is in progress.

- oracle + firebird: "case sensitivity" feature will detect an all-lowercase
case-sensitive column name during reflect and add
"quote=True" to the generated Column, so that proper
quoting is maintained.

- the "threadlocal" engine has been rewritten and simplified
and now supports SAVEPOINT operations.

clarify intent

disable SAWarning exceptions when supports_sane_rowcount isn't supported so
VersioningTest can complete

- types.Binary is renamed to types.LargeBinary, it only
produces BLOB, BYTEA, or a similar "long binary" type.
New base BINARY and VARBINARY
types have been added to access these MySQL/MS-SQL specific
types in an agnostic way [ticket:1664].

- association_proxy now has basic comparator methods .any(),
.has(), .contains(), ==, !=, thanks to Scott Torborg.
[ticket:1372]

not applicable to zxjdbc

arrange imports, cleanup

send along the sqlsoup engine for encoding purposes.

- ensure correct session usage + tests

use issubclass here, allows lazy loads from a subclass to hit a loader that was configured on base

add autoflush to the list of attributes exported on scoped_session

fixed the illegal_initial_chars collection + unit test, [ticket:1659]

base supports_native_enum on 8.3 or greater

- agnosticize checking for the two phase events

fix ResultProxy for SQLite truncated names

  - query.select_from() also accepts mapped classes, aliased()
    constructs, and mappers as arguments.  In particular this
    helps when querying from multiple joined-table classes to ensure
    the full join gets rendered.

moved the metadata step of ResultProxy into a ResultMetaData object.  this also replaces PickledResultProxy.
Allows RowProxy objects to reference just the metadata they need and provides the "core" of ResultProxy
detached from the object itself, allowing ResultProxy implementations to vary more easily.  will also
enable [ticket:1635]

lessons learned unpickling from an 0.5 cache

- mega example cleanup
- added READMEs to all examples in each __init__.py and added to sphinx documentation
- added versioning example
- removed vertical/vertical.py, the dictlikes are more straightforward

some cleanup