remove unneeded _OracleDateTime/_OracleTimestamp cx_oracle types, streamline _OracleDate, [ticket:1600]

- merged r6526 from 0.5 branch + some additional formatting fixes, [ticket:1597]

- fixed the import for entrypoint-driven dialects to
not rely upon silly tb_info trick to determine import
error status.  [ticket:1630]

  - an explicit check occurs when a synonym() is used with
    map_column=True, when a ColumnProperty (deferred or otherwise)
    exists separately in the properties dictionary sent to mapper
    with the same keyname.   Instead of silently replacing
    the existing property (and possible options on that property),
    an error is raised.  [ticket:1633]

- The cursor associated with connection pool connections
(i.e. _CursorFairy) now proxies `__iter__()` to the
underlying cursor correctly. [ticket:1632]

primaryjoin/secondaryjoin accept ColumnElement, docs, [ticket:1622]

- changed a few isinstance(value, Decimal) to "is not None", where appropriate
- fixed result processor for Numeric(asdecimal=False) on MSSQL.

- relation primaryjoin and secondaryjoin now check that they
are column-expressions, not just clause elements.  this prohibits
things like FROM expressions being placed there directly.
[ticket:1622]

typo

test fails on zxjdbc

Prelookup codec in the String result processor for dialects which do not
return Unicode natively, as suggested in #1323. Provides a nice speed boost
(~21% total query time).

add NATIONAL CHAR test

- VARCHAR/NVARCHAR will not render without a length, raises
an error before passing to MySQL.   Doesn't impact
CAST since VARCHAR is not allowed in MySQL CAST anyway,
the dialect renders CHAR/NCHAR in those cases.
[ticket:1252]

add an interesting from_statement() format

revert part of the change of r6510 because "select datetime('now')" in SQLite
does not contain microseconds

- sqlite
    - DATE, TIME and DATETIME types can now take optional storage_format and
      regexp argument. storage_format can be used to store those types using
      a custom string format. regexp allows to use a custom regular expression
      to match string values from the database.
    - Time and DateTime types now use by a default a stricter regular
      expression to match strings from the database. Use the regexp argument
      if you are using data stored in a legacy format.
    - __legacy_microseconds__ on SQLite Time and DateTime types is not
      supported anymore. You should use the storage_format argument instead.
    - Date, Time and DateTime types are now stricter in what they accept as
      bind parameters: Date type only accepts date objects (and datetime ones,
      because they inherit from date), Time only accepts time objects, and
      DateTime only accepts date and datetime objects.

minor speed optimization in String result_processor (if decoding is required)

minor speed optimization for PGArray bind & result processors

- Fixed bug whereby composite columns wouldn't load properly
when configured on a joined-table subclass, introduced in
version 0.5.6 as a result of the fix for [ticket:1480].
[ticket:1616] thx to Scott Torborg.

merge r6504 from 0.5 plus an enhancement to the unit test, [ticket:1611]

- Removed unused `load()` method from ShardedQuery.
[ticket:1606]

start relying on new unicode detection fully - remove isinstance() from the unicode result processing.

- pg8000 + postgresql dialects now check for float/numeric return
types to more intelligently determine float() vs. Decimal(),
[ticket:1567]
- since result processing is a hot issue of late, the DBAPI type
returned from cursor.description is certainly useful in cases like
these to determine an efficient result processor.   There's likely
other result processors that can make use of it.  But, backwards
incompat change to result_processor().  Happy major version number..

fix StaticPool [ticket:1615]

merge r6497 of 0.5 branch

reduce some call overhead

scan for autocommit based on text() specific flag, saves isinstance() call on each execution.

- new oursql dialect added.  [ticket:1613]

dont run sqlsoup test on jython

- subclassed Function off of new FunctionElement generic base
- removed "key" accessor of Function, Grouping - this doesn't seem to be used for anything
- various formatting
- documented the four "Element" classes in the compiler extension as per [ticket:1590]

test fix, [ticket:1595]

- ForeignKey(constraint=some_parent) is now private _constraint
- ForeignKey and ForeignKeyConstraint objects now correctly
copy() all their public keyword arguments.  [ticket:1605]

- query.get() can be used with a mapping to an outer join
where one or more of the primary key values are None.
[ticket:1135]

add test for map explicit Table

- added a real unit test for sqlsoup
- removed doctest stuff
- redid session docs for sqlsoup
- sqlsoup stays within the transaction of a Session now, is explcitly autocommit=False by default and includes commit()/rollback() methods
- sqlsoup db.<sometable>.update() and delete() now call
query(cls).update() and delete(), respectively.
- sqlsoup now has execute() and connection(), which call upon
the Session methods of those names, ensuring that the bind is
in terms of the SqlSoup object's bind.

moved modified_event() calls below the attribute extension fires.  this basically has no difference in any case except that where an extension is calling commit() on the attribute -  in that case it usually, but not always, maintains the same history.   [ticket:1601]

allow setattr() access to _CursorFairy directly, thereby removing the need for dialects to guess whether they have a wrapped cursor or not, fixes #1609, regression from r6471

supports unicode binds in PG too.  even without the UNICODE extension it seems to work now...

Within NamedTuple, izip is faster on most cases, and equally fast on others

use list comprehension instead of generator as it is much faster for small
lists, as will usually be the case here. provides a ~11% speedup for large
column-only queries.

- Fixed bug in two-phase transaction whereby commit() method
didn't set the full state which allows subsequent close()
call to succeed. [ticket:1603]

- Fixed bug where Query would crash if a join() with no clear
"left" side were called when a non-mapped column entity
appeared in the columns list. [ticket:1602]

Using generators for small lists is highly inefficient. This change shoves
6% of total time for large ORM queries. Not bad for a 2 characters change :)

- simplify default schema name test
- MySQL + zxjdbc *is* unicode by default.  it was the broken initialize()

fix MySQL initialize to use defaultdialect first

- The "start" and "increment" attributes on Sequence now
generate "START WITH" and "INCREMENT BY" by default,
on Oracle and Postgresql.  Firebird doesn't support
these keywords right now.  [ticket:1545]

- Connection pool logging now uses both INFO and DEBUG
log levels for logging.  INFO is for major events such
as invalidated connections, DEBUG for all the acquire/return
logging.  `echo_pool` can be False, None, True or "debug"
the same way as `echo` works.

- dialect.get_default_schema_name(connection) is now
public via dialect.default_schema_name.
[ticket:1571]

 * tweaked PickleType result_processor and bind_processor so that they are more
   correct and more easily maintainable.
 * implemented specific result_processor and bind_processor for Interval type
   to avoid TypeDecorator call overhead (closes #1598)

rewrote PickleType bind_processor and result_processors to bypass TypeDecorator
call overhead and avoid pickler function lookup for each row (see #1598).
Provides a speedup of ~7 % on total query time for a 1000 record query on a
table with 1 PickeType field and 25% None values.

- Fixed the call to get_committed_value() on CompositeProperty.
[ticket:1504]

revert r6466

- Fixed the call to get_committed_value() on CompositeProperty.
[ticket:1504]

added a test for #1349

omit this test for non-oracle

fix adapt() so that DB-specified typedecorator replacements work

- INTERVAL supports an optional "precision" argument
corresponding to the argument that PG accepts.
- Added support for reflecting the INTERVAL YEAR TO MONTH
and INTERVAL DAY TO SECOND syntaxes of the INTERVAL
type.  [ticket:460]

- filter out SYS_NC\d+$ columns [ticket:1513]
- remove explicit INNER JOIN from index query to support oracle 8

added test for [ticket:1450]

add "dialect" to the __all__ of each root dialect package

- added py3k and "OS Independent" classifiers

- the `__contains__()` method of `MetaData` now accepts
strings or `Table` objects as arguments.  If given
a `Table`, the argument is converted to `table.key` first,
i.e. "[schemaname.]<tablename>" [ticket:1541]

get more speed out of the Time type on Mysql

get a bit more speed out of datetime and LOB-based types on cx_oracle

added comment so that other people don't spend their time trying to optimize
optimal code

minor speed improvement on date, datetime and time types on SQLite

large speed improvement of the Interval type on non-native dialects

slightly sped-up Binary type, PickleType and all TypeDecorators

added docs to case() illusrtating usage of `literal_column()`, can't implement #809 directly

partially PEP8-ified informix dialect

no native unicode for mysql + zxjdbc

whats up with the native_unicode test on jython

test fixes

oracle test fixes

- The psycopg2 dialect now uses psycopg2's "unicode extension"
on all new connections, which allows all String/Text/etc.
types to skip the need to post-process bytestrings into
unicode (an expensive step due to its volume).  Other
dialects which return unicode natively (pg8000, zxjdbc)
also skip unicode post-processing.

- String/Text/Unicode types now skip the unicode() check
on each result column value if the dialect has
detected the DBAPI as returning Python unicode objects
natively.  This check is issued on first connect
using "SELECT CAST 'some text' AS VARCHAR(10)" or
equivalent, then checking if the returned object
is a Python unicode.   This allows vast performance
increases for native-unicode DBAPIs, including
pysqlite/sqlite3, psycopg2, and pg8000.

- generalized Enum to issue a CHECK constraint + VARCHAR on default platform
- added native_enum=False flag to do the same on MySQL, PG, if desired

well great nobody even supports PG enum.

- Using a "dynamic" loader with a "secondary" table now produces
a query where the "secondary" table is *not* aliased.  This
allows the secondary Table object to be used in the "order_by"
attribute of the relation(), and also allows it to be used
in filter criterion against the dynamic relation.
[ticket:1531]

- a "dynamic" loader sets up its query criterion at construction
time so that the actual query is returned from non-cloning
accessors like "statement".

fix errant 2.6ism

- Fixed a slight inaccuracy in the sharding example.
Comparing equivalence of columns in the ORM is best
accomplished using col1.shares_lineage(col2).
[ticket:1491]

- Added new ENUM type to the Postgresql dialect, which exists as a schema-level
construct and extends the generic Enum type.  Automatically
associates itself with tables and their parent metadata
to issue the appropriate CREATE TYPE/DROP TYPE
commands as needed, supports unicode labels, supports
reflection.  [ticket:1511]

- MySQL ENUM now subclasses the new generic Enum type, and also handles
unicode values implicitly, if the given labelnames are unicode
objects.

- Added a new Enum generic type, currently supported on
Postgresql and MySQL.  Enum is a schema-aware object
to support databases which require specific DDL in
order to use enum or equivalent; in the case of PG
it handles the details of `CREATE TYPE`, and on
other databases without native enum support can
support generation of CHECK constraints.
[ticket:1109] [ticket:1511]

- types documentation updates

- some cleanup on schema/expression docs

- apply ged's suggested optimization of not needlessly wrapping mapper._instance_processor
- start playing with semi-automated 78-col wrapping

fix some 2.4 callcounts

- ResultProxy internals have been overhauled to greatly reduce
method call counts when fetching columns that have no
type-level processing applied.   Provides a 100% speed
improvement when fetching large result sets with no unicode
conversion.  Many thanks to Elixir's Gaëtan de Menten
for this dramatic improvement !  [ticket:1586]

update counts for 2.4

- Mutable collection passed to the "extension" attribute
of relation(), column_property() etc. will not be mutated
or shared among multiple instrumentation calls, preventing
duplicate extensions, such as backref populators,
from being inserted into the list.
[ticket:1585]

- insert() and update() constructs can now embed bindparam()
      objects using names that match the keys of columns.  These
      bind parameters will circumvent the usual route to those
      keys showing up in the VALUES or SET clause of the generated
      SQL. [ticket:1579]

Removed references to sequence in MSSQL

Implicit identities in mssql work the same as implicit sequences on any
other dialects. Explicit sequences are enabled through the use of
"default=Sequence()". See the MSSQL dialect documentation for more
information.

- RETURNING is supported by 8.2+
- add docs for PG delete..returning

- Corrected the "has_sequence" query to take current schema,
or explicit sequence-stated schema, into account.
[ticket:1576]

some cleanup

merged scopefunc patch from r6420 of 0.5 branch

merge r6418 from 0.5, dedupe expressions on clause ident, not string value
[ticket:1574]

merged r6416 of 0.5 branch, fix the "numeric" paramstyle and add tests

Fix reST markup

Modernise doc about returning() support

attempt to fix some jython ordering annoyingness

- the behavior of eagerloading such that the main query is
wrapped in a subquery when LIMIT/OFFSET are present now
makes an exception for the case when all eager loads are
many-to-one joins. In those cases, the eager joins are
against the parent table directly along with the
limit/offset without the extra overhead of a subquery,
since a many-to-one join does not add rows to the result.

- added a flag to relation(), eagerload(), and eagerload_all()
called 'innerjoin'.  Specify `True` or `False` to control
whether an eager join is constructed as an INNER or OUTER
join.   Default is `False` as always.   The mapper options
will override whichever setting is specified on relation().
Should generally be set for many-to-one, not nullable
foreign key relations to allow improved join performance.
[ticket:1544]

- initial MySQL Connector/Python driver
- support exceptions raised in dialect initialize phase
- provide default dialect create_connect_args() method