Fixed up the pypostgresql PGNumeric bind_processor to convert input to a string.

Corrected dbengine.rst file to properly render nested lists.  Thank you Diana Clarke. Fixes #1700.

- Composite PK table on InnoDB where the "autoincrement" column
isn't first will emit an explicit "KEY" phrase within
CREATE TABLE thereby avoiding errors, [ticket:1496]

Fixed native unicode test to work with pypostgresql.

Added a basic .hgignore file.

fix a typo, [ticket:1662]

Python 3 changes the round to return a Decimal not a float.

Fixed up the pypostgresql dialect so it appears in __init__.

generalized "test all the picklers" iterator works cross platform

increase the timeout here to accommodate slowness on the buildbot

clean up some skips, added skip for sqlite + python2

extract fix

Fixed cPickle problem in Python3.

more py3k fixes

remove __cmp__, move to __lt__ , __eq__ per http://docs.python.org/dev/3.0/whatsnew/3.0.html#ordering-comparisons

another weird nose + py3k fix

unicode fix that gets around nose's stringio usage

callcounts

- Fixed cascade bug in many-to-one relation() when attribute
was set to None, introduced in r6711 (cascade deleted
items into session during add()).

- A change to the solution for [ticket:1579] - an end-user
defined bind parameter name that directly conflicts with
a column-named bind generated directly from the SET or
VALUES clause of an update/insert generates a compile error.
This reduces call counts and eliminates some cases where
undesirable name conflicts could still occur.

tighten up conditionals a bit.  this method is still doing too much, i.e. the whole pre-visit step is pricey.

silliness

get tests to pass for OurSQL

pg8000 doesn't seem to support this either

some more 2.4 test fixes

2.6.4 has higher numbers for some reason here

2.4 fix

exclude this test for everyone but sqlite

update call counts

more cleanup

Gave the "state" internals a good solid
cleanup with less complexity, datamembers,
method calls, blank dictionary creates.

- fix C version of rowproxy pickling so that it pickles to the same format
  as the Python version.
- changelog my earlier processor optimization work

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.