test/base/alltests passes in 3k

most folks dont put "./lib/" in their PYTHONPATH.   so replace with the same approach as that of util.

use sqlalchemy.util functions here.  the previous implementation is
not compatible with py3k.   I can run all tests or any combination of tests
by using sqlalchemy.util so it's not clear to me why sqlalchemy.util
reportedly cannot be imported at this phase.

Switched ext compiler test to use sqlite.

Get the callable import right.

Callable must be defined before path magic occurs.

Resolved merge conflict.

Couple more corrections to get mssql tests to pass.

py3king

2to3 wrapper which includes a preprocessor

test fixes

Fixed up some of the mssql dialect tests for date handling.

correct subclassing

jek's name change

doc

- dialect.type_descriptor() becomes a classmethod
- TypeEngine caches types in impl_dict per dialect class
[ticket:1299]

A couple of cleanup items to remove pdb and correct dialect name on informix.

mssql type fixes....

Corrections to MSSQL Date/Time types; generalized server_version_info to a create_engine() pre-step

0.6 development branch

- the 'expire' option on query.update() has been renamed to 'fetch', thus matching
that of query.delete()
- query.update() and query.delete() both default to 'evaluate' for the synchronize
strategy.
- the 'synchronize' strategy for update() and delete() raises an error on failure.
There is no implicit fallback onto "fetch".   Failure of evaluation is based
on the structure of criteria, so success/failure is deterministic based on
code structure.

hand-merged pg/mssql changes from trunk -r5699:5727

merged -r5699:5727 of trunk

One more mssql dialect test fix.

Working through dialect changes.

A couple of fixes for the mssql dialect to correct restructuring / renaming.

caps adjust

some import fixes

- mssql dialects are in place, not fully tested

- pg uses generic Biginteger now
- fix to _is_excluded() function

a little guide on how im thinking about types

remove pyc

- moved all the dialects over to their final positions
- structured maxdb, sybase, informix dialects.  obviously no testing has been done.

merged -r5676:5699 of trunk

import cleanup

- added a compiler extension that allows easy creation of user-defined compilers,
which register themselves with custom ClauseElement subclasses such that the compiler
is invoked along with the primary compiler.  The compilers can also be registered
on a per-dialect basis.

This provides a supported path for SQLAlchemy extensions such as ALTER TABLE
extensions and other SQL constructs.

- oracle support, includes fix for #994

pg8000 handling unicode fine now

- more or less pg8000 support. has a rough time with non-ascii data.
- removed "send unicode straight through" logic from sqlite, this becomes
base dialect configurable
- simplfied Interval type to not have awareness of PG dialect.  dialects
can name TypeDecorator classes in their colspecs dict.

convert_unicode by default clears up the issue for now

more mysql+pyodbc fixes

merge -r5673:5675 of trunk

- mysql+pyodbc working for regular usage, ORM, etc.   types and unicode still flaky.
- updated testing decorators to receive  "name+driver"-style specifications

more test fixup, type correction

the most epic dialect of all.  the MYSQL DIALECT.  didn't port the dialect test over yet.

our likely approach towards documentation of generic driver + dbapi driver

merge -r5658:5665 from trunk

first merge from the hg repo.  may need cleanup/refreshing

break out dialects and drivers

prefer this methods

- It's an error to add new Column objects to a declarative class
that specified an existing table using __table__.

- Column with no name (as in declarative) won't raise a
NoneType error when it's string output is requsted
(such as in a stack trace).

- Fixed a bug with the unitofwork's "row switch" mechanism,
i.e. the conversion of INSERT/DELETE into an UPDATE, when
combined with joined-table inheritance and an object
which contained no defined values for the child table where
an UPDATE with no SET clause would be rendered.

- Tightened up **kw on ColumnProperty and its front-end functions.

happy new year

- Can now specify Column objects on subclasses which have no
table of their own (i.e. use single table inheritance).
The columns will be appended to the base table, but only
mapped by the subclass.

- For both joined and single inheriting subclasses, the subclass
will only map those columns which are already mapped on the
superclass and those explicit on the subclass.  Other
columns that are present on the `Table` will be excluded
from the mapping by default, which can be disabled
by passing a blank `exclude_properties` collection to the
`__mapper_args__`.  This is so that single-inheriting
classes which define their own columns are the only classes
to map those columns.   The effect is actually a more organized
mapping than you'd normally get with explicit `mapper()`
calls unless you set up the `exclude_properties` arguments
explicitly.

- docs/tests

oh, its UNION ordering that's changing

more comparator tweaks

Ensure RowTuple names are correct by adding "key" to QueryableAttribute.

suspect the InstrumentedSet/set comparison is failing for some reason

*more* sqlite appeasement

mysql/pg sensitive fixes

don't INSERT a blank row if no rows passed. (breaks all the tests for SQLite on the buildbot....)

NotSupportedError is a DBAPI wrapper which takes four args and is expected to originate from the DBAPI layer.
Moved those error throws to CompileError/InvalidRequestError.

added an order by

- Concrete inheriting mappers now instrument attributes which are inherited from the superclass, but are not defined for the concrete mapper itself, with an InstrumentedAttribute that issues a descriptive error when accessed.  [ticket:1237]
- Added a new `relation()` keyword `back_populates`.  This allows configuation of backreferences using explicit relations. [ticket:781]  This is required when creating bidirectional relations between a hierarchy of concrete mappers and another class. [ticket:1237]
- Test coverage added for `relation()` objects specified on concrete mappers. [ticket:1237]
- A short documentation example added for bidirectional relations specified on concrete mappers. [ticket:1237]
- Mappers now instrument class attributes upon construction with the final InstrumentedAttribute object which remains persistent.  The `_CompileOnAttr`/`__getattribute__()` methodology has been removed.  The net effect is that Column-based mapped class attributes can now be used fully at the class level without invoking a mapper compilation operation, greatly simplifying typical usage patterns within declarative. [ticket:1269]
- Index now accepts column-oriented InstrumentedAttributes (i.e. column-based mapped class attributes) as column arguments.  [ticket:1214]
- Broke up attributes.register_attribute into two separate functions register_descriptor and register_attribute_impl.    The first assembles an InstrumentedAttribute or Proxy descriptor, the second assembles the AttributeImpl inside the InstrumentedAttribute.  register_attribute remains for outside compatibility.  The argument lists have been simplified.
- Removed class_manager argument from all but MutableScalarAttributeImpl (the branch had removed class_ as well but this has been reverted locally to support the serializer extension).
- Mapper's previous construction of _CompileOnAttr now moves to a new MapperProperty.instrument_class() method which is called on all MapperProperty objects at the moment the mapper receives them. All MapperProperty objects now call attributes.register_descriptor within that method to assemble an InstrumentedAttribute object directly.
- InstrumentedAttribute now receives the "property" attribute from the given PropComparator.  The guesswork within the constructor is removed, and allows "property" to serve as a mapper compilation trigger.
- RelationProperty.Comparator now triggers compilation of its parent mapper within a util.memoized_property accessor for the "property" attribute, which is used instead of "prop" (we can probably remove "prop").
- ColumnProperty and similar handle most of their initialization in their __init__ method since they must function fully at the class level before mappers are compiled.
- SynonymProperty and ComparableProperty move their class instrumentation logic to the new instrument_class() method.
- LoaderStrategy objects now add their state to existing InstrumentedAttributes using attributes.register_attribute_impl.  Both column and relation-based loaders instrument in the same way now, with a unique InstrumentedAttribute *and* a unique AttributeImpl for each class in the hierarchy.  attribute.parententity should now be correct in all cases.
- Removed unitofwork.register_attribute, and simpified the _register_attribute methods into a single function in strategies.py.  unitofwork exports the UOWEventHandler extension directly.
- To accomodate the multiple AttributeImpls across a class hierarchy, the sethasparent() method now uses an optional "parent_token" attribute to identify the "parent".  AbstractRelationLoader sends the MapperProperty along to serve as this token.  If the token isn't present (which is only the case in the attributes unit tests), the AttributeImpl is used instead, which is essentially the same as the old behavior.
- Added new ConcreteInheritedProperty MapperProperty.  This is invoked for concrete mappers within _adapt_inherited_property() to accomodate concrete mappers which inherit unhandled attributes from the base class, and basically raises an exception upon access.  [ticket:1237]
- attributes.register_attribute and register_descriptor will now re-instrument an attribute unconditionally without checking for a previous attribute.  Not sure if this is controversial. It's needed so that ConcreteInheritedProperty instrumentation can be overridden by an incoming legit MapperProperty without any complexity.
- Added new UninstrumentedColumnLoader LoaderStrategy.  This is used by the polymorphic_on argument when the given column is not represented within the mapped selectable, as is typical with a concrete scenario which maps to a polymorphic union.  It does not configure class instrumentation, keeping polymorphic_on from getting caught up in the new concrete attribute-checking logic.
- RelationProperty now records its "backref" attributes using a set assigned to `_reverse_property` instead of a scalar.  The `back_populates` keyword allows any number of properties to be involved in a single bidirectional relation.  Changes were needed to RelationProperty.merge(), DependencyProcessor to accomodate for the new multiple nature of this attribute.
- Generalized the methodology used by ManyToManyDP to check for "did the other dependency already handle this direction", building on the `_reverse_property` collection.
- post_update logic within dependency.py moves to use the same methodology as ManyToManyDP so that "did the other dependency do this already" checks are made to be specific to the two dependent instances.
- Caught that RelationProperty.merge() was writing to instance.__dict__ directly (!) - repaired to talk to instance_state.dict.
- Removed needless eager loading example from concrete mapper docs.
- Added test for [ticket:965].
- Added the usual Node class/nodes table to orm/_fixtures.py, but haven't used it for anything yet.   We can potentially update test/orm/query.py to use this fixture.
- Other test/documentation cleanup.

Corrected SAVEPOINT support on the adodbapi dialect by changing the handling
of savepoint_release, which is unsupported on mssql.

The way it was being discarded previously resulted in an empty execute being
called on the dialect; adodbapi didn't like that much.

Modified the do_begin handling in mssql to use the Cursor not the Connection.

This corrects a problem where we were trying to call execute on the Connection
object instead of against the cursor. This is supported on pyodbc but not in
the DBAPI. Overrode the behavior in pymssql to not do special do_begin
processing on that dialect.

- 0.5.1 bump
- modernized mapper()/no table exception
- added __tablename__ exception to declarative since ppl keep complaining

clarified docs on foreign key cascades, mapper extension methods during delete() and update() methods

query.delete(False) is not so bad

Added the missing keywords from MySQL 4.1 so they get escaped properly.

typo

Formatting fixups

doh its 0.5.0

move memusage to the isolation chamber

- removed 2.3 compat stuff
- updated MANIFEST for the newer build

next release is 0.5.0

- query.join() raises an error when the target of the join
doesn't match the property-based attribute - while it's
unlikely anyone is doing this, the SQLAlchemy author was
guilty of this particular loosey-goosey behavior.

Forgot to sqash a commit. Follow up on mssql dates refactoring.

mssql date / time refactor.
- Added new MSSmallDateTime, MSDateTime2, MSDateTimeOffset, MSTime types
- Refactored the Date/Time types. The smalldatetime data type no longer
  truncates to a date only, and will now be mapped to the MSSmallDateTime
  type. Closes #1254.

made the "you passed a non-aliased selectable" warning scarier.  scarier !

- property.of_type() is now recognized on a single-table
inheriting target, when used in the context of
prop.of_type(..).any()/has(), as well as
query.join(prop.of_type(...)).

if at first you don't succeed, fail, fail again

assume table.schema, not None, when constraint reflection has no explicit schema.  unit test TBD.

- Generalized the IdentityManagedState._instance_dict() callable
to the IdentityMap class so that Weak/StrongInstanceDict both
have the same behavior wrt the state referencing the map
- Fixed bug when using weak_instance_map=False where modified
events would not be intercepted for a flush(). [ticket:1272]

Corrected a few docs and didn't realize we put pyodbc first in the search list.

docstrings for the hated fold_equivalents argument/function

added teardown_instance() to complement setup_instance().
Based on the instance/class agnostic behavior of ClassManager, this might be the best we can
do regarding [ticket:860]

- query.order_by() accepts None which will remove any pending
order_by state from the query, as well as cancel out any
mapper/relation configured ordering. This is primarily useful
for overriding the ordering specified on a dynamic_loader().
[ticket:1079]

added the significant test for #1247

Corrected an issue on mssql where Numerics would not accept an int.

added order_by test coverage as per [ticket:1218]

one more typo

fixed critical errors in assocationproxy docs while we wait for the all new and improved version

- Fixed bug which was preventing out params of certain types
from being received; thanks a ton to huddlej at wwu.edu !
[ticket:1265]

identified the SQLite changes which affect default reflection

Added a note about mssql compatibility levels.

send a NASA probe to the buildbot

Flagged two versioning tests as failing on MSSQL. The flush occurs even though
there should be a concurrency issue.

I cheated and marked these as FIXME. With this commit all MSSQL tests pass
now. The work of correcting the ``fails_on`` tests begins.