- changed 'desired_columns' argument to 'include_columns'
- made 'include_columns' an explicit argument to Table.  I'm
trying to avoid the "x can be a foo, or a bar, or a list of dictionaries of hoho's"-type behavior
- added unit test, closes [ticket:561]

- ANSICompiler now uses its own traversal when compiling, returning a composed
string from each visit_XXXX method, so that the full string is compiled at once
without using any dictionary storage.  dialects modified accordingly.
tested on mysql/sqlite/postgres fully,
tested with string-only tests for oracle/fb/informix/mssql so far.

"You can also specify a list or set of column names to autoload, if you only want to load a subset of the columns in the actual database."

fixes #561

fix up a docstring and some examples

- removed the ridiculous AbstractDialect do-nothing class
- fixup to docstrings

typo fix (unbreak test suite)

Really finish proxied list methods. Either these last couple (count, remove, setitem w/ slice) weren't possible in 0.3 and/or I spaced these.
Improved messaging on flubbed stepped slice assignment in collection decorators.

add checks for well-formed ColumnProperty.  fixes #683

add __repr__ for engine, metadata, sqlsoup

use sha instead of crypt to decrease suckage for windows users.  also crypt kinda blows anyway

- added unittest for sharding module
- fixed shard test/example datatype to "Float" since Numeric
behavior has changed
- added docstrings to sqlalchemy/orm/__init__.py functions;
still need to proof within generated HTML pages/fix errors
- added engine.threadlocal to docs, removed old mods.threadlocal

test graceful fallback to lazy loading for cyclical eager load with no join_depth

- added has(), like any() but for scalars
- added **kwargs to has() and any(), criterion is optional; generate equality criterion
against the related table (since we know the related property when has() and any() are used),
i.e. filter(Address.user.has(name='jack')) equivalent to filter(Address.user.has(User.name=='jack'))
- added "from_joinpoint=False" arg to join()/outerjoin().  yes, I know join() is getting a little
crazy, but this flag is needed when you want to keep building along a line of aliased joins,
adding query criterion for each alias in the chain.  self-referential unit test added.
- fixed basic_tree example a little bit

renamed new scalar() method to as_scalar(), not deprecating normal ClauseElement.scalar()...

restored Float's full constructor to play better with overriding types, i.e. mysql.MSFloat

- deprecated scalar=True argument on select().  its replaced
by select().scalar() which returns a _ScalarSelect object, that obeys
the ColumnElement interface fully
- removed _selectable() method.  replaced with __selectable__() as an optional
duck-typer; subclassing Selectable (without any __selectable__()) is equivalent
- query._col_aggregate() was assuming bound metadata.  ick !
- probably should deprecate ClauseElement.scalar(), in favor of ClauseElement.execute().scalar()...
otherwise might need to rename select().scalar()

- Numeric and Float types now have an "asdecimal" flag; defaults to
True for Numeric, False for Float.  when True, values are returned as
decimal.Decimal objects; when False, values are returned as float().
the defaults of True/False are already the behavior for PG and MySQL's
DBAPI modules. [ticket:646]

- ColumnCollection (i.e. the 'c' attribute on tables) follows dictionary
semantics for "__contains__" [ticket:606]

- a rudimental sharding (horizontal scaling) system is introduced.  This system
uses a modified Session which can distribute read and write operations among
multiple databases, based on user-defined functions defining the
"sharding strategy".  Instances and their dependents can be distributed
and queried among multiple databases based on attribute values, round-robin
approaches or any other user-defined system. [ticket:618]

deprecated extra arguments on instances()

removed methods instance_key(), identity_key(), identity()

- joined-table inheritance will now generate the primary key
columns of all inherited classes against the root table of the
join only.  This implies that each row in the root table is distinct
to a single instance.  If for some rare reason this is not desireable,
explicit primary_key settings on individual mappers will override it.

- When "polymorphic" flags are used with joined-table or single-table
inheritance, all identity keys are generated against the root class
of the inheritance hierarchy; this allows query.get() to work
polymorphically using the same caching semantics as a non-polymorphic get.
note that this currently does not work with concrete inheritance.

Oops, --log-{info,debug}= args need to accept values...

patched fix for [ticket:677], thanks !

ColumnDefault functions pass ExecutionContext to callables which accept a single argument;
refactored workings of defaults so that they share the same execution context.

_ConnectionRecord gains a .properties collection, with contents scoped to
the lifetime of the underlying DBAPI connection.  Accessors on Connections and fairies.

corrected literals_as_binds to recognize sql.Operators objects for [ticket:675]

Rearrange profiling a bit

- refinement of connection.execute() , parameter processing behavior
- Connection's dealings with params are simplified; generation of
ClauseParameters pushed into DefaultDialect.
- simplified ClauseParameters.
- this is to make room for execute_raw() but I haven't decided how that
should look yet.

Finished up the workflow in ormsession test

Refactored test support code, moved most into 'testlib/'
Cleaned up imports, all tests should be runnable stand-alone or suite now
Updated most of the perf tests
Removed dead test suites
Added new profiling decorator
Added new profilable perf test, 'ormsession' to try to capture a typical workload

added some of the newer query styles to some inheritance tests.  more inheritance + new query stuff needs to be tested

fixed up testbase coverage to get module-level stuff
fixed activemapper tests

dead

removed small cruftlet

- fix to _CalculatedClause._copy_internals() behavior so that ClauseAdapter works with _Function objects better
- factored AliasedClauses out of EagerLoader into its own unit; Query makes heavy use of it for joins
- added support to Query for full interaction between aliased and nonalised joins with appended entities, columns, and externally-mapped columns

Consigned to history.

- got self-referential query.join()/query.outerjoin() to work.
- PropertyLoader adds local_side set which is the opposite of remote_side, makes
the self-referential aliasing a snap.
- added "id" argument to join()/outerjoin() to allow access to the aliased joins
in add_entity().
- added "alias" argument to add_entity() to get at entities selected from an explicit
Alias
- starting to move EagerLoader.AliasedClasues to a general utility function which
will be used by Query as well

filter_by([joinpath], ...) is gone.  join([path], aliased=True) replaces it, all subsequent filter() criterion is converted
against that alias; represents a much more flexible and consistent solution.
needs some tweaks and can then work with self-referential loading too.

Queries now __str__ as their statement

make this test runnable stand-alone

- merged bind unittest fix from r2999

REV 3000 !!!  WOO HOO !

- added query.populate_existing().. - marks the query to reload
  all attributes and collections of all instances touched in the query,
  including eagerly-loaded entities [ticket:660]

- added eagerload_all(), allows eagerload_all('x.y.z') to specify eager
  loading of all properties in the given path

merged most recent overflow mutex tweak

dont clobber existing methodnames, [ticket:596]

implemented Class.any(criterion)

changed assignmapper API per [ticket:636]

merged pool fix from [changeset:2989] and timeout fix from [changeset:2990]

-  Eager loading now functions at any arbitrary depth along self-referential
and cyclical structures.  When loading cyclical structures, specify "join_depth"
on relation() indicating how many times you'd like the table to join
to itself; each level gets a distinct table alias.
- adds a stack to the Mapper->eagerloader->Mapper process which is the single
point of tracking the various AliasedClause objects both at query compile
time as well as result fetching time.  self-referential relationships narrow
down the "aliasing" of tables more sharply so as to produce the correct
eager joins in those cases without stepping on more generalized cases.
the mechanism of detecting "too deep" of an eager load now works based on
locating a true cycle, but only if join_depth is not specified; otherwise
join_depth is used.
[ticket:659]

Remove unused imports, typo and light formatting tweaks.
Fixed comparison of _UnaryExpressions

Remove mysql enum out of range test, not really needed and seems WAY too dependent on server version

small fix to detect a "scalar" query when constructing columns clauses

- changed set used to generate FROM list to an ordered set; may fix [ticket:669]
- improvements to select generative capability, ClauseAdapter
- one select test is failing, but not from this checkin

Better quoting of identifiers when manipulating schemas.

added info on DB types

docstrings

removed ancient group_parenthesized() method, its purpose handled by _Grouping now

fixed LIKE/BEWTEEN operators

removed print statement...this is the year i start using a debugger

- all "type" keyword arguments, such as those to bindparam(), column(),
  Column(), and func.<something>(), renamed to "type_".  those objects
  still name their "type" attribute as "type".
- new SQL operator implementation which removes all hardcoded operators
  from expression structures and moves them into compilation;
  allows greater flexibility of operator compilation; for example, "+"
  compiles to "||" when used in a string context, or "concat(a,b)" on
  MySQL; whereas in a numeric context it compiles to "+".  fixes [ticket:475].
- major cruft cleanup in ANSICompiler regarding its processing of update/insert
  bind parameters.  code is actually readable !
- a clause element embedded in an UPDATE, i.e. for a correlated update, uses
  standard "grouping" rules now to place parenthesis.  Doesn't change much, except
  if you embed a text() clause in there, it will not be automatically parenthesized
  (place parens in the text() manually).

Target testcreate schema test better.

Clarity fix for assocproxy example code

.pop() on association proxies is no longer problematic with 0.4 collections.

- unittest cleanup: after removal of threadlocal mod + changes to session calling signature,
got sqlite, postgres, mysql all working again (one unresolved failure for mysql)

partial progress on adding prop.compare(), new behavior for prop ==

added some aggregate tests

- merged fix of PG identifier length from 68 to 63 [ticket:571]
- merged r2958, commutativity for _BinaryExpression.compare

- put a generic regexp for chopping foreign key specs along the "."
[ticket:667]

- Merged r2945, r2946, r2947 from trunk
- Cache 'lower_case_table_names' test for the lifetime of a connection
- Clean up compat fetch stuff

typo

- changed the order of args to session.execute(), session.scalar()
- removed session.connect().  theres only connection()
- implemented twophase flag on session, twophase calls within SessionTransaction,
one unit test so far which tests that it succeeds (but doesnt test a failure yet or
do any mocking)
- rewrote session transaction docs

Properly escape table names when reflecting for mssql and sqlite [ticket:653]

Rewrote association proxy documentation to be more accessible and promote the general awesomeness of association proxies.

- removed ancient threadlocal/legacy_session mods
- Session now has tranasaction API built into it, SessionTransaction not part of the usual API now (but still does the work)
- integrated nested transactions/SAVEPOINT with Session transactional system
- Session gets "transactional" mode, it always begins a transaction and reopens after commit/rollback
- Session gets "autoflush=True" flag, implies "transactional", issues a flush before the execution of every
query so that query results include whatever is currently in the session
- various unit test fixes

- Adjust has_table for MySQL, workaround multibyte issue on osx

another order_by fix

- got in_() working, enhanced sql.py treatment of Comparator so comparators can be used in any SQL expression (i.e. order bys, desc(), etc.)
- adding various tests for new clause generation

- added operator support to class-instrumented attributes. you can now
filter() (or whatever) using <classname>.<attributename>==<whatever>.
for column based properties, all column operators work (i.e. ==, <, >,
like(), in_(), etc.).  For relation() and composite column properties,
==<instance>, !=<instance>, and ==<None> are implemented so far.
[ticket:643]

- moved query._with_parent into prop.compare() calls
- built extensible operator framework in sql package, ORM
builds on top of it to shuttle python operator objects back down
to the individual columns.  no relation() comparisons yet.  implements
half of [ticket:643]

Ignore generated doc build artifacts

Tweak collections doc to fit in with long-lines club.

- Finish collections doc changes started in r2839, expanding coverage in
  main documentation and docstrings.
- Per list discussion, removed backward compat. for dict- and object-derived
  collection types.  This is the safest course of action given the major
  change in dict iterator behavior.
- Minor typos and code cleanups.

removed get_str(), get_from_text() from ansicompiler.  removes a few hundred method calls

regexp searches for negative decimals too

When testing unicode for MySQL, ensure the connection is utf8

fix to connection-bound compiled objects

fix to SessionTransaction so it holds onto a Connection properly

few more tweaks for the aliasing change

- converted all anonymous labels and aliases to be generated within the compilation phase.  this allows fully "deterministic" label generation. theres a couple of unit test failures that need to be fixed but most are passing.
- also some tweaks to unicode result column names; no longer chopping out characters from the names, since the name might be composed of all non-ascii characters.  mysql needs some work here since its returning, i think, the unicode's internally-encoded bytes directly within a bytestring.
- need to simplify the amount of dictionaries present in ANSICompiler, its pretty hard to follow at this point.

removed some remaining "connectable"/"bind_to" keywords

completed connectable/bind_to/engine work for [ticket:645]

merged trunk r2901-2924

- bind test in query.orm
- merged ambiguous colname fix from r2915

added some text tests

- merged trunk r2880-r2901 (slightly manually for 2900-2901)
- merges "bind" argument change
- merges join fixes for [ticket:185]
- removed all "engine"/"connectable"/"bind_to"/"engine_or_url" arguments/attributes

context manager support for sql transactions

add support for two phase commits, nested subtransactions and savepoints. refactors Transaction class into a hierarchy.

added some order_bys to eager relations, which otherwise load with different
ordering on PG.  we might want to get eager relations on m2m to handle default order-by differently

dont log statement + parameters if logging is not enabled

added polymorphic associations examples from the trunk