- the "scale" argument of the Numeric() type is honored when
coercing a returned floating point value into a string
on its way to Decimal - this allows accuracy to function
on SQLite, MySQL.  [ticket:1717]

fix unicode warnings

add docstring for remove [ticket:1715]

Match tests have been completely wrong.

Corrected problem with index too large on mysql.

- merge -r6823:6841 of branches/chrisw_mixin
- declarative now accepts mixin classes directly, as a means
to provide common functional and column-based elements on
all subclasses, as well as a means to propagate a fixed
set of __table_args__ or __mapper_args__ to subclasses.
For custom combinations of __table_args__/__mapper_args__ from
an inherited mixin to local, descriptors can now be used.
New details are all up in the Declarative documentation.
Thanks to Chris Withers for putting up with my strife
on this. [ticket:1707]

modify the py3k check to check for bytes

- walk back r6851 slightly.  Still emit a warning when the Unicode or UnicodeText type
is passed a bytestring even if the backend accepts unicodes directly.

- The assert_unicode flag is deprecated.  SQLAlchemy will raise
a warning in all cases where it is asked to encode a non-unicode
Python string, and will do nothing for DBAPIs that already
accept Python unicode objects.

Support for the mysql+oursql dialect. Thank you Taavi Burns.

Corrected a lot of mssql test issues related to Binary being deprecated and replaced with LargeBinary.

Added the ability to strip the schema when using tometadata by passing schema=None as an argument. Fixes #1673.

Corrected the py3k docs so that you can properly use python3 to run 2to3.  Thanks Taavi Burns.

Copy paste fail.

Fixed binary tests for mssql based on how the new types are being used.

fix typo

- A major fix in query.join(), when the "on" clause is an
attribute of an aliased() construct, but there is already
an existing join made out to a compatible target, query properly
joins to the right aliased() construct instead of sticking
onto the right side of the existing join.  [ticket:1706]

- "out" parameters require a type that is supported by
cx_oracle.  An error will be raised if no cx_oracle
type can be found.
- Column() requires a type if it has no foreign keys (this is
not new).  An error is now raised if a Column() has no type
and no foreign keys.  [ticket:1705]

add some py3k caveats

- Added reflection/create table support for a wide range
of MySQL keywords.  [ticket:1634]

rename "error" kwarg to "errors" to be consistent with builtin unicode
conversion functions.

- typos
- type classes have a lot of detail in their constructors

- Added "unicode_errors" parameter to String, Unicode, etc.
Behaves like the 'errors' keyword argument to
the standard library's string.decode() functions.   This flag
requires that `convert_unicode` is set to `"force"` - otherwise,
SQLAlchemy is not guaranteed to handle the task of unicode
conversion.   Note that this flag adds significant performance
overhead to row-fetching operations for backends that already
return unicode objects natively (which most DBAPIs do).  This
flag should only be used as an absolute last resort for reading
strings from a column with varied or corrupted encodings,
which only applies to databases that accept invalid encodings
in the first place (i.e. MySQL. *not* PG, Sqlite, etc.)

The pypostgresql has a problem coercing an array during concatination. Exclude test.

Removed the text_as_varchar option in the mssql dialect. It wasn't being used.

a handy @classproperty decorator

long lines

Major cleanup work in the docs to link class names into the API docs. Fixes #1702.

Work around py-postgresql handling of exceptions.

- a change to the previous __mapper_args__ commit.
- the __mapper_args__ dict is copied when propagating to a subclass,
and is taken straight off the class __dict__ to avoid any
propagation from the parent.  mapper inheritance already
propagates the things you want from the parent mapper.
[ticket:1393]

- the __mapper_args__ dict is copied when propagating to a subclass.
Still need to decide how the argument propagation should
work in the bigger picture.  [ticket:1393]

- session.merge() will not expire existing scalar attributes
on an existing target if the target has a value for that
attribute, even if the incoming merged doesn't have
a value for the attribute.  This prevents unnecessary loads
on existing items.  Will still mark the attr as expired
if the destination doesn't have the attr, though, which
fulfills some contracts of deferred cols.  [ticket:1681]

- session.merge() works with relations that specifically
don't include "merge" in their cascade options - the target
is ignored completely.

Changed the py-postgresql dialect to indicate that it is using the pyformat parameter style.

Modified unittests docs to explain that --first-package-wins=True is required on Windows. Also modified the setup.cfg to add this option so that if using the default config there will be consistent behavior on all platforms.

- The "allow_null_pks" flag is now called "allow_partial_pks",
defaults to True, acts like it did in 0.5 again.  Except,
it also is implemented within merge() such that a SELECT
won't be issued for an incoming instance with partially
NULL primary key if the flag is False.  [ticket:1680]

The py-postgresql dialect supports raw python.

- DeclarativeMeta exclusively uses cls.__dict__ (not dict_)
as the source of class information; _as_declarative exclusively
uses the  dict_ passed to it as the source of class information
(which when using DeclarativeMeta is cls.__dict__).  This should
in theory make it easier for custom metaclasses to modify
the state passed into _as_declarative.

Found another float / Decimal issue that needs to be changed to be consistent on Python2/3.

The py-postgresql dialect now supports sane rowcounts.

add import for "random"

- added util.portable_instancemethod to provide a quick way to make an instancemethod "serializable"
- SchemaType and subclasses Boolean, Enum are now serializable,
including their ddl listener and other event callables.
[ticket:1694] [ticket:1698]
- AddConstraint/DropConstraint use the wrapper for _create_rule
- added test coverage for AddConstraint override of _create_rule

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.