start sketching ideas for a rewritten unit of work.
the basic idea is to bring topological back down to the raw function,
then the whole UOW constructs itself as very fine grained elements with
full dependencies to each other.  then a straight execute with a straight sort.
the hope is that the mechanism here would be vastly simpler.  while
the presence of a large number of fine-grained records may be expensive
it still is potentially a lot easier to distill into C code, as the
uow's structure now consists of data.

rename test_select to test_compiler

- join() will now simulate a NATURAL JOIN by default.  Meaning,
if the left side is a join, it will attempt to join the right
side to the rightmost side of the left first, and not raise
any exceptions about ambiguous join conditions if successful
even if there are further join targets across the rest of
the left.  [ticket:1714]

- An exception is raised when a single-table subclass specifies
a column that is already present on the base class.
[ticket:1732]

branch merge

- added "lockmode" kw argument to Session.refresh(), will
pass through the string value to Query the same as
in with_lockmode(), will also do version check for a
version_id_col-enabled mapping.

nobody expects the insanely significant decimal

- get firebird on board
- a lot of these drivers suck at decimals, not sure what to do

make this test slightly easier, SQLite + win32 appears to not like it otherwise

don't seem to need bind processing for pg8000 decimals.

still poking at numerics

distinguish between small, large, and many significant digits.  the irony
that oracle and sybase are the ones that have the most issues with decimal numbers.

- the string approach appears to be necessary for large numbers, however.
Don't know how to get large decimals through to Sybase.

switching Decimal treatment in MSSQL to be pyodbc specific, added
to connector to share between sybase/mssql.   Going
with turning decimals with very low significant digit to floats,
seems to work so far.

some more tests.  unfortunately i cant run them here since my osx freetds/pyodbc is hosed

Merged latest tip

fixed missing return statement which caused render_literal_value to choke

some CHANGES moving around

Added MSSQLStrictCompiler support for rendering datetime types

- normalize sybase version numbers
- sybase has 255 identifier length on 15, 30 earlier

Added module docstring for mssql+mxodbc dialect.

Removed MxNumeric and MxFloat because now the sqlalchemy.types base classes support dialects having a class attribute of "supports_native_decimal" indicating native Python Demimal support. Adjusted mssql+mxodbc to use the sqlalchemy.types base classes for Float and Numeric instead of using the base mssql dialect's numeric types.

- oracle needs a filter for this test
- oracle outparam test reveals usage of numeric proc with scale==None

some weird numerictype coming back from pysybase, run through float()

clean up NumericTest to use a consistent one column at a time system

removed mxODBC imports from the module level

adjustments to improve readability (indentation to complex conditional expressions, excessively long lines brokenup). This is only a partial cleanup.

Hardcoded ident_seed and ident_increment query had bind markers noncompliant with SQL-92, which caused mxODBC failures. This was corrected by using string substitution in building the statement, and removing the bind params.

Merged from main tip.

per zzzeek, for mssql+mxodbc, disabled test.sql.test_query.QueryTest.test_bind_in

cx_oracle adjust

adjustment for pysybase

turning the decimals to floats allows the E notation to work with sybase+pyodbc for small E notations

- moved most Decimal bind/result handling into types.py, out of sqlite, mysql dialects.
- added an explicit test for [ticket:1216]
- some questions remain about MSSQL - would like to simplify/remove bind handling for numerics

comments/question about using connection.closed in is_disconnect method

Merge

Docstring improvements for MxDecimal and MxNumeric result processors.

eGenix says "It's better to let mxODBC decide which bind type to use."

some ms fixes

latex can't handle the rowspans.  pdf still cuts off the table and looks like
crap but at least it builds.

if anybody complains that they didn't know it was called "relation" in 0.5, why..I'll eat my hat !

add a synonym for RelationProperty -> RelationshipProperty too

Because of changes to SQLAlchemy bind parameter placement, removed all mxodbc test disabling statements having this pattern: @testing.crashes('mssql+mxodbc', """Invalid bind parameter placement:

merged from main tip

Merged from main tip, and resolved conflicts in mxodbc dialect and connector.

- The official name for the relation() function is now
relationship(), to eliminate confusion over the relational
algebra term.  relation() however will remain available
in equal capacity for the foreseeable future.  [ticket:1740]

working through syb capabilities

Setting default bindmethod to BIND_USING_SQLTYPE, since this should provide better type conversion performance.

Added decimalformat binding ( I thought this was committed earlier)

- pyodbc can do *some* unicode with sybase, python-sybase not at all.
Since python-sybase source code seems to be all from 2001 with no updates,
making pyodbc the default driver.

- added pyodbc for sybase driver.
- generalized the "freetds" / "unicode statements" behavior of MS-SQL/pyodbc
into the base Pyodbc connector, as this seems to apply to Sybase as well.
- generalized the python-sybase "use autocommit for DDL" into the pyodbc
connector.  With pyodbc, the "autocommit" flag on connection is used,
as Pyodbc seems to have more database conversation than python-sybase that
can't otherwise be suppressed.
- Some platforms will now interpret certain literal values
as non-bind parameters, rendered literally into the SQL
statement.   This to support strict SQL-92 rules that are
enforced by some platforms including MS-SQL and Sybase.
In this model, bind parameters aren't allowed in the
columns clause of a SELECT, nor are certain ambiguous
expressions like "?=?".  When this mode is enabled, the base
compiler will render the binds as inline literals, but only across
strings and numeric values.  Other types such as dates
will raise an error, unless the dialect subclass defines
a literal rendering function for those.  The bind parameter
must have an embedded literal value already or an error
is raised (i.e. won't work with straight bindparam('x')).
Dialects can also expand upon the areas where binds are not
accepted, such as within argument lists of functions
(which don't work on MS-SQL when native SQL binding is used).

- basic sybase+pyodbc support.  in particular this will impact freetds detection for MS-SQL as well.

Changed OurSQL to use supports_unicode_binds and supports_unicode_statements.

- mxodbc can use default execute() call
- modified SQLCompiler to support rendering of bind parameters as literal
inline strings for specific sections, if specified by the compiler
subclass, using either literal_binds=True passed to process() or any visit
method, or by setting to False the "binds_in_columns_clause" flag for SQL-92
compatible columns clauses..  The compiler subclass is responsible for
implementing the literal quoting function which should make use of the DBAPI's native
capabilities.
- SQLCompiler now passes **kw to most process() methods (should be all,
ideally) so that literal_binds is propagated.
- added some rudimentary tests for mxodbc.

corrected import statements forgotten on prior commit

Disabling tests for mssql+mxodbc where mxODBC cursor.execute chokes on invalid placement of bind parameter "?" within the SQL statement.

Fixes to pass numeric tests; now by default, the mxodbc connector natively returns Python Decimal data types from columns of type SQL.NUMERIC or SQL.DECIMAL

Added module docstring for mxodbc connector

- The except_() method now renders as MINUS on Oracle,
which is more or less equivalent on that platform.
[ticket:1712]

- Fixed bug which caused "row switch" logic, that is an
INSERT and DELETE replaced by an UPDATE, to fail when
version_id_col was in use. [ticket:1692]

- Added "version_id_generator" argument to Mapper, this is a
callable that, given the current value of the "version_id_col",
returns the next version number.  Can be used for alternate
versioning schemes such as uuid, timestamps.  [ticket:1692]

- added test for #1737
- the fix from r502f1a4f92d5 broke another rare use case, one-to-one on a PK/FK combo which apparently enables use_get.
 fortunate that another test waiting in trac reveals this.

removed junk pdb.set_trace()

Removed custom do_execute which called cursor.executedirect, after discussion with eGenix and zzzeek. Even though more tests pass with executedirect, it is not appropriate for default usage because it does not issue prepare statements to the db, and it forces Python type binding. The executedirect method should only be called when the API user specifically requests it for special case performance reasons.

adjust mxodbc imports to dialect level

merged mainline default branch

using executemany instead of executedirect, which passes more tests than with plain execute. Later we need to define logic to determine when to call the normal execute.

- The visit_pool() method of Dialect is removed, and replaced with
on_connect().  This method returns a callable which receives
the raw DBAPI connection after each one is created.   The callable
is assembled into a first_connect/connect pool listener by the
connection strategy if non-None.   Provides a simpler interface
for dialects.

whitespace fixes to improve readability (shortened excessively long lines, and one 5-space indentation block corrected to 4 spaces).

fix failing test due to sybase paramstyle

- name all the "sub" dialect components <DB><component>_<dialectname>, [ticket:1738]

- many incantations to get the tests to run reasonably
- executemany() for some reason uses some tiny buffer, overriding it
- we need to use the IDENTITY_INSERT thing

- initial working version of sybase, with modifications to the transactional
model to accomodate Sybase's default mode of "no ddl in transactions".
- identity insert not working yet.  it seems the default here might be the
opposite of that of MSSQL.
- reflection will be a full rewrite
- default DBAPI is python-sybase, well documented and nicely DBAPI compliant
except for the bind parameter situation, where we have a straightforward workaround
- full Sybase docs at: http://infocenter.sybase.com/help/index.jsp?topic=/com.sybase.help.ase_15.0/title.htm

starting to add notes for sybase

merge of the "database chart" diff

- Fixed bug in 0.6-reworked "many-to-one" optimizations
such that a many-to-one that is against a non-primary key
column on the remote table (i.e. foreign key against a
UNIQUE column) will pull the "old" value in from the
database during a change, since if it's in the session
we will need it for proper history/backref accounting,
and we can't pull from the local identity map on a
non-primary key column. [ticket:1737] (test is pending)

ongoing typos

gr and pysqlite

update link for sqlite3

the big table of all the DBAPIs

working dialect support into a chart

- further checks when running in WITH_UNICODE
- When WITH_UNICODE
mode is used in Python 2.xx, a large and scary warning
is emitted asking that the user seriously consider
the usage of this difficult mode of operation.
[ticket:1670]

callcount...

arg, oracle, bah

ensure with_unicode flag is false for cx_oracle < 5

merge tip

- Added "logging_name" argument to create_engine(), Pool() constructor
as well as "pool_logging_name" argument to create_engine() which
filters down to that of Pool.   Issues the given string name
within the "name" field of logging messages instead of the default
hex identifier string.  [ticket:1555]

adjust per a couple zxjdbc failures

only enable WITH_UNICODE when >= cx_Oracle v5

- query.get() now returns None if queried for an identifier
that is present in the identity map with a different class
than the one requested, i.e. when using polymorphic loading.
[ticket:1727]

merge tip

fix the timeout test once and for all

tweak to take advantage of returning support in executemany

disable interval tests on oracle+zxjdbc for now, and also test_fk_nonpassive

fix extending of a tuple

move the initial connect out of the profile zone so we don't get a method call hit on that

further refinement

merging master...

consolidate unicode/CLOB handling

adjust to allow mock DBAPIs

oursql doesn't like the cursor being reused without fetch being finished