some more docstring patches for [ticket:214]

- fix for fetchmany() "size" argument being positional in most
dbapis [ticket:505]

- fixes [ticket:185], join object determines primary key and removes
columns that are FK's to other columns in the primary key collection.
- removed workaround code from query.py get()
- removed obsolete inheritance test from mapper
- added new get() test to inheritance.py for this particular issue
- ColumnCollection has nicer string method

- some logging cleanup
- added 'encodedname' prop to a few ClauseElements to aid logging

- preliminary support for unicode table and column names added.

msssql: more unit tests now pass

- improved/fixed custom collection classes when giving it "set"/
"sets.Set" classes or subclasses (was still looking for append()
methods on them during lazy loads)
- moved CustomCollectionsTest from unitofwork to relationships
- added more custom collections test to attributes module

- column labels are now generated in the compilation phase, which
means their lengths are dialect-dependent.  So on oracle a label
that gets truncated to 30 chars will go out to 63 characters
on postgres.  Also, the true labelname is always attached as the
accessor on the parent Selectable so theres no need to be aware
of the genrerated label names [ticket:512].
- ResultProxy column targeting is greatly simplified, and relies
upon the ANSICompiler's column_labels map to translate the built-in
label on a _ColumnClause (which is now considered to be a unique
identifier of that column) to the label which was generated at compile
time.
- still need to put a baseline of ColumnClause targeting for
ResultProxy objects that originated from a textual query.

cleanup continued

various cleanup, docs and things, getting ready for 0.3.6

documenting generative methods on query

- MetaData can bind to an engine either via "url" or "engine" kwargs
to constructor, or by using connect() method.  BoundMetaData is
identical to MetaData except engine_or_url param is required.
DynamicMetaData is the same and provides thread-local connections
be default.

dan's latest patch for session.identity_key()

- CLOB type descends from TEXT so it goes to the dialect correctly
- oracle CLOB has result value LOB handling

- added explicit MSTimeStamp type which takes effect when using
types.TIMESTAMP.

- slightly better support for bind params as column clauses, either
via bindparam() or via literal(), i.e. select([literal('foo')])
- removed "table" argument from column().  this does not add the column
to the table anyway so was misleading.
- Select _exportable_columns() only exports Selectable instances
- Select uses _exportable_columns() when searching for engines
instead of _raw_columns for similar reasons (non selectables have no engine)
- _BindParamClause no longer has a _make_proxy().  its not a ColumnElement.
- _Label detects underlying column element and will generate its own
column()._make_proxy() if the element is not a ColumnElement.  this
allows a Label to be declared for nearly anything and it can export
itself as a column on a containing Selectable.

contextual_connection()  -> contextual_connect() [ticket:515]

the "tack on the leftover tasks at the end" step of the "circular dependency sort"
makes a copy of those tasks with the circular_parent marked.  this way the tasks
do not iterate through their child items polymorphically, which is necessary because
the "circular sort" stores individual subclass tasks separately (i.e. saving/deleting
should not traverse polymorhically for those tasks)

- many-to-many table will be properly handled even for operations that
occur on the "backref" side of the operation [ticket:249]

mssql: now passes still more unit tests, [ticket:481]

- added db modules to genned docstrings
- had to tweak out latest MS-SQL module change.  cant do ImportErrors right now until module
importing is moved to the connection phase across all dialects.
- took out "his" from url docstrings
- postgres doesnt do an import *

- check for tables in the primaryjoin/secondaryjoin that arent parent of parent/child mappers.
dont include those clauses when looking for foreign_keys (which also takes care of remote_side).
if those cols are present in foreign_keys, lazyloader makes binds out of them and tries to
target those columns on the mapper, raising either the "conflicting column" error if they have the same
name, or the "cant find column on mapping" if it has a unique name.  added tests for both.

mssql: cleanup of module importing code; specifiable DB-API module; more explicit ordering of module preferences. [ticket:480]

mssql: optionally use VARCHAR(max) instead of TEXT. [ticket:509]

- flush fixes on self-referential relationships that contain references
to other instances outside of the cyclical chain, when the initial
self-referential objects are not actually part of the flush

css tag

integrated docutils formatting into generated documentation;
restructuredtext fixes throughout docstrings

merged mako doc generation branch

- added a catchall **kwargs to MSString, to help reflection of
obscure types (like "varchar() binary" in MS 4.0)

"alltests" runners call testbase.main(), which takes an optional suite,
so that exit code is propigated

literals in PassiveDefault require text()

MSSQL now passes still more unit tests [ticket:481]
Fix to null FLOAT fields in mssql-trusted.patch
MSSQL: LIMIT with OFFSET now raises an error
MSSQL: can now specify Windows authorization
MSSQL: ignores seconds on DATE columns (DATE fix, part 1)

fix CASE statement when else_ is zero

- eager loading will not "aliasize" "order by" clauses that were placed
in the select statement by something other than the eager loader
itself, to fix possibility of dupe columns as illustrated in
[ticket:495].  however, this means you have to be more careful with
the columns placed in the "order by" of Query.select(), that you have
explicitly named them in your criterion (i.e. you cant rely on the
eager loader adding them in for you)

- query._join_to (which powers join, join_via, etc) properly takes
secondary table into account when constructing joins

- added a handy multi-use "identity_key()" method to Session, allowing
the generation of identity keys for primary key values, instances,
and rows, courtesy Daniel Miller

some docs

some formatting

- for hackers, refactored the "visitor" system of ClauseElement and
SchemaItem so that the traversal of items is controlled by the
ClauseVisitor itself, using the method visitor.traverse(item).
accept_visitor() methods can still be called directly but will
not do any traversal of child items.  ClauseElement/SchemaItem now
have a configurable get_children() method to return the collection
of child elements for each parent object. This allows the full
traversal of items to be clear and unambiguous (as well as loggable),
with an easy method of limiting a traversal (just pass flags which
are picked up by appropriate get_children() methods). [ticket:501]
- accept_schema_visitor() methods removed, replaced with
get_children(schema_visitor=True)
- various docstring/changelog cleanup/reformatting

- oracle:
    - got binary working for any size input !  cx_oracle works fine,
      it was my fault as BINARY was being passed and not BLOB for
      setinputsizes (also unit tests werent even setting input sizes).
    - auto_setinputsizes defaults to True for Oracle, fixed cases where
      it improperly propigated bad types.

- Query has add_entity() and add_column() generative methods.  these
will add the given mapper/class or ColumnElement to the query at compile
time, and apply them to the instances method.  the user is responsible
for constructing reasonable join conditions (otherwise you can get
full cartesian products).  result set is the list of tuples, non-uniqued.
- fixed multi-mapper instances() to pad out shorter results with None so
zip() gets everything

- the full featureset of the SelectResults extension has been merged
into a new set of methods available off of Query.  These methods
all provide "generative" behavior, whereby the Query is copied
and a new one returned with additional criterion added.
The new methods include:

  filter() - applies select criterion to the query
  filter_by() - applies "by"-style criterion to the query
  avg() - return the avg() function on the given column
  join() - join to a property (or across a list of properties)
  outerjoin() - like join() but uses LEFT OUTER JOIN
  limit()/offset() - apply LIMIT/OFFSET
  range-based access which applies limit/offset:
     session.query(Foo)[3:5]
  distinct() - apply DISTINCT
  list() - evaluate the criterion and return results

no incompatible changes have been made to Query's API and no methods
have been deprecated.  Existing methods like select(), select_by(),
get(), get_by() all execute the query at once and return results
like they always did.  join_to()/join_via() are still there although
the generative join()/outerjoin() methods are easier to use.

- the return value for multiple mappers used with instances() now returns
a cartesian product of the requested list of mappers, represented
as a list of tuples.  this corresponds to the documented behavior.
So that instances match up properly, the "uniquing" is disabled when
this feature is used.
- strings and columns can also be sent to the *args of instances() where
those exact result columns will be part of the result tuples.
- query() method is added by assignmapper.  this helps with
navigating to all the new generative methods on Query.

cleanup of reversed

- fixed usage of 2.4-only "reversed" in topological.py [ticket:506]

- fixed use_alter flag on ForeignKeyConstraint [ticket:503]

- options() method on SelectResults now implemented "generatively"
like the rest of the SelectResults methods [ticket:472]

need an "alias()" on map to a select

decorated ImportError thrown when the <database>:// module isnt found

added "enable_typechecks=True" flag on relation so the new type check from #500 can be disabled, since people are going to want to disable it.

- added concept of 'require_embedded' to corresponding_column.
requires that the target column be present in a sub-element of the
target selectable.
- embedded logic above more appropriate for ClauseAdapter functionality
since its trying to "pull up" clauses that represent columns within
a larger union up to the level of the union itself.
- the "direction" test against the "foreign_keys" collection apparently
works for an exact "column 'x' is present in the collection", no proxy
relationships needed.  fixes the case of relating a selectable/alias
to one of its underlying tables, probably fixes other scenarios

- put an aggressive check for "flushing object A with a collection
of B's, but you put a C in the collection" error condition -
**even if C is a subclass of B**, unless B's mapper loads polymorphically.
Otherwise, the collection will later load a "B" which should be a "C"
(since its not polymorphic) which breaks in bi-directional relationships
(i.e. C has its A, but A's backref will lazyload it as a different
instance of type "B") [ticket:500]

dont continue remote table if warning

"modernized" polymorph test, name change to "test_roundtrip"

- bindparam() names are now repeatable!  specify two
distinct bindparam()s with the same name in a single statement,
and the key will be shared.  proper positional/named args translate
at compile time.  for the old behavior of "aliasing" bind parameters
with conflicting names, specify "unique=True" - this option is
still used internally for all the auto-genererated (value-based)
     bind parameters.

cleanup; removed "separate foreign key" tests, polymorphic joined-table inheritance requires the same pk col name across tables;
added additional polymorphic load assertions

- added "fold_equivalents" argument to Join.select(), which removes
'duplicate' columns from the resulting column clause that are known to be
equivalent based on the join condition.  this is of great usage when
constructing subqueries of joins which Postgres complains about if
duplicate column names are present.
- added support to polymorphic stuff for more than one "equivalent column",
when trying to target columns in the polymorphic union; this applies
to multi-leveled inheritance
- put above-two concepts together to get the abc_inheritance tests to work
with postgres

- use_labels flag on select() wont auto-create labels for literal text
column elements, since we can make no assumptions about the text. to
create labels for literal columns, you can say "somecol AS somelabel",
or use literal_column("somecol").label("somelabel")
- quoting wont occur for literal columns when they are "proxied" into the
column collection for their selectable (is_literal flag is propigated)

added a unit test for nested session transactions

a generating testcase that tests a three-level inheritance chain (A->B->C) and all one-to-many and many-to-one relationships between
all distinct A,B,C.  still needs support for foreign key to parent table not the same col as the pk col

this test works with both one to many and many to one, but i think its intended to be one-to-many

- fixed function execution with explicit connections, when you dont
explicitly say "select()" off the function, i.e.
conn.execute(func.dosomething())

migrated (most) docstrings to pep-257 format, docstring generator using straight <pre> + trim() func
for now.  applies most of [ticket:214], compliemnts of Lele Gaifax

- more fixes to polymorphic relations, involving proper lazy-clause
generation on many-to-one relationships to polymorphic mappers
[ticket:493]

fix typo

- added "refresh-expire" cascade [ticket:492]

- correlated subqueries work inside of ORDER BY, GROUP BY

- exists() becomes useable as a standalone selectable, not just in a
WHERE clause

- a full select() construct can be passed to query.select() (which
worked anyway), but also query.selectfirst(), query.selectone() which
will be used as is (i.e. no query is compiled). works similarly to
sending the results to instances().

restored sequence back, needed by PG for the unit test

- added selectfirst(), selectfirst_by() to assign_mapper [ticket:467]

added collengths to use varchar instead of TEXT

- removed deprecated method of specifying custom collections on classes;
you must now use the "collection_class" option. the old way was
beginning to produce conflicts when people used assign_mapper(), which
now patches an "options" method, in conjunction with a relationship
named "options". (relationships take precedence over monkeypatched
assign_mapper methods).

formatting fix

formatting/cleanup

  - eager relation loading bug fixed for eager relation on multiple
  descendant classes [ticket:486]

Tested with pymssql 0.8.0
mssql: added query_timeout, fixes for passing auto_insert in dburl

fix to the fix for [ticket:454], prevent other mappers in a load operation from using the main extension option send to the query (i.e. mappers used for eager loads etc).

- added "contains_alias()" option for result set mapping to an alias of the mapped table

  - added "alias" argument to contains_eager().  use it to specify the string name
    or Alias instance of an alias used in the query for the eagerly loaded child items.
    easier to use than "decorator"

- moved SynonymProperty to interfaces, since its more generalized and synonym-aware operations
take place without knowning so much about properties
- mapper options like eagerload(), lazyload(), deferred(), will work for "synonym()" relationships [ticket:485]

removed not-always-applicable check for "polymorphic_identity"

- documented foreign_keys argument
- 0.3.5 markers

reverted unit test change

- oracle issues a log warning when a related table cant be reflected due to certain
permission errors [ticket:363]

Completed previously missed patches from tickets 422 and 415
get unit tests to work with pyodbc [ticket:481]
fix blank password on adodbapi [ticket:371]

- modified patch for [ticket:379] - detecting synonyms, dblinks in reflection.  test passes
except for DBLINK which I cannot get to work on my oracle-xe database.
- probable (also untested) fix for [ticket:363], better error message if we get None back for
remote table information (which is due to rights)

- fixes to tometadata() operation to propigate Constraints at column and table level

- fixed generation of CHECK constraints on columns [ticket:464]

- extension() query option propigates to Mapper._instance() method so that
all loading-related methods get called [ticket:454]

- moved change for [ticket:466] to ansisql, since thats the syntax for all databases.
the change is across all dialects, not just oracle

added PGInet type [ticket:444]

- added a Sequence to the unicode test tables to help Oracle
- fixed named PrimaryKeyConstraint generation on oracle [ticket:466] courtesy andrija at gmail

[ticket:463] fix to OrderedSet

commented out ImportError for now; will issue new ticket for handling dialect importerrors more effectively

- fixed oracle list of binary types to check for their presence in the module (such as BFILE not in all versions of cx_Oracle)
- removed oracle-handicap from binary unit test to test [ticket:435] fix, added an extra row containing None

- small fix to BoundMetaData to accept unicode or string URLs

better MSSSQL support for implicit sequences and auto-insert, ticket 415

Fix Fix for adodbapi bug introduced by ticket 419

Func rewrite for better unittest compatibility
Simplified transaction handling for pymssql

dont do RAWTOHEX on None