Remove submodule, just put Dependencies in ./libs

libs/sqlalchemy/orm/dynamic.py

@@ -0,0 +1,306 @@
+# orm/dynamic.py
+# Copyright (C) 2005-2011 the SQLAlchemy authors and contributors <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""Dynamic collection API.
+
+Dynamic collections act like Query() objects for read operations and support
+basic add/delete mutation.
+
+"""
+
+from sqlalchemy import log, util
+from sqlalchemy import exc as sa_exc
+from sqlalchemy.orm import exc as orm_exc
+from sqlalchemy.sql import operators
+from sqlalchemy.orm import (
+    attributes, object_session, util as mapperutil, strategies, object_mapper
+    )
+from sqlalchemy.orm.query import Query
+from sqlalchemy.orm.util import has_identity
+from sqlalchemy.orm import attributes, collections
+
+class DynaLoader(strategies.AbstractRelationshipLoader):
+    def init_class_attribute(self, mapper):
+        self.is_class_level = True
+
+        strategies._register_attribute(self,
+            mapper,
+            useobject=True,
+            impl_class=DynamicAttributeImpl,
+            target_mapper=self.parent_property.mapper,
+            order_by=self.parent_property.order_by,
+            query_class=self.parent_property.query_class
+        )
+
+    def create_row_processor(self, selectcontext, path, mapper, row, adapter):
+        return None, None, None
+
+log.class_logger(DynaLoader)
+
+class DynamicAttributeImpl(attributes.AttributeImpl):
+    uses_objects = True
+    accepts_scalar_loader = False
+    supports_population = False
+
+    def __init__(self, class_, key, typecallable,
+                     target_mapper, order_by, query_class=None, **kwargs):
+        super(DynamicAttributeImpl, self).\
+                    __init__(class_, key, typecallable, **kwargs)
+        self.target_mapper = target_mapper
+        self.order_by = order_by
+        if not query_class:
+            self.query_class = AppenderQuery
+        elif AppenderMixin in query_class.mro():
+            self.query_class = query_class
+        else:
+            self.query_class = mixin_user_query(query_class)
+
+    def get(self, state, dict_, passive=False):
+        if passive:
+            return self._get_collection_history(state,
+                    passive=True).added_items
+        else:
+            return self.query_class(self, state)
+
+    def get_collection(self, state, dict_, user_data=None, passive=True):
+        if passive:
+            return self._get_collection_history(state,
+                    passive=passive).added_items
+        else:
+            history = self._get_collection_history(state,
+                    passive=passive)
+            return history.added_items + history.unchanged_items
+
+    def fire_append_event(self, state, dict_, value, initiator):
+        collection_history = self._modified_event(state, dict_)
+        collection_history.added_items.append(value)
+
+        for ext in self.extensions:
+            ext.append(state, value, initiator or self)
+
+        if self.trackparent and value is not None:
+            self.sethasparent(attributes.instance_state(value), True)
+
+    def fire_remove_event(self, state, dict_, value, initiator):
+        collection_history = self._modified_event(state, dict_)
+        collection_history.deleted_items.append(value)
+
+        if self.trackparent and value is not None:
+            self.sethasparent(attributes.instance_state(value), False)
+
+        for ext in self.extensions:
+            ext.remove(state, value, initiator or self)
+
+    def _modified_event(self, state, dict_):
+
+        if self.key not in state.committed_state:
+            state.committed_state[self.key] = CollectionHistory(self, state)
+
+        state.modified_event(dict_, 
+                                self, 
+                                False, 
+                                attributes.NEVER_SET, 
+                                passive=attributes.PASSIVE_NO_INITIALIZE)
+
+        # this is a hack to allow the _base.ComparableEntity fixture
+        # to work
+        dict_[self.key] = True
+        return state.committed_state[self.key]
+
+    def set(self, state, dict_, value, initiator,
+                        passive=attributes.PASSIVE_OFF):
+        if initiator and initiator.parent_token is self.parent_token:
+            return
+
+        self._set_iterable(state, dict_, value)
+
+    def _set_iterable(self, state, dict_, iterable, adapter=None):
+        collection_history = self._modified_event(state, dict_)
+        new_values = list(iterable)
+        if state.has_identity:
+            old_collection = list(self.get(state, dict_))
+        else:
+            old_collection = []
+        collections.bulk_replace(new_values, DynCollectionAdapter(self,
+                                 state, old_collection),
+                                 DynCollectionAdapter(self, state,
+                                 new_values))
+
+    def delete(self, *args, **kwargs):
+        raise NotImplementedError()
+
+    def set_committed_value(self, state, dict_, value):
+        raise NotImplementedError("Dynamic attributes don't support "
+                                  "collection population.")
+
+    def get_history(self, state, dict_, passive=False):
+        c = self._get_collection_history(state, passive)
+        return attributes.History(c.added_items, c.unchanged_items,
+                                  c.deleted_items)
+
+    def _get_collection_history(self, state, passive=False):
+        if self.key in state.committed_state:
+            c = state.committed_state[self.key]
+        else:
+            c = CollectionHistory(self, state)
+
+        if not passive:
+            return CollectionHistory(self, state, apply_to=c)
+        else:
+            return c
+
+    def append(self, state, dict_, value, initiator, passive=False):
+        if initiator is not self:
+            self.fire_append_event(state, dict_, value, initiator)
+
+    def remove(self, state, dict_, value, initiator, passive=False):
+        if initiator is not self:
+            self.fire_remove_event(state, dict_, value, initiator)
+
+class DynCollectionAdapter(object):
+    """the dynamic analogue to orm.collections.CollectionAdapter"""
+
+    def __init__(self, attr, owner_state, data):
+        self.attr = attr
+        self.state = owner_state
+        self.data = data
+
+    def __iter__(self):
+        return iter(self.data)
+
+    def append_with_event(self, item, initiator=None):
+        self.attr.append(self.state, self.state.dict, item, initiator)
+
+    def remove_with_event(self, item, initiator=None):
+        self.attr.remove(self.state, self.state.dict, item, initiator)
+
+    def append_without_event(self, item):
+        pass
+
+    def remove_without_event(self, item):
+        pass
+
+class AppenderMixin(object):
+    query_class = None
+
+    def __init__(self, attr, state):
+        Query.__init__(self, attr.target_mapper, None)
+        self.instance = instance = state.obj()
+        self.attr = attr
+
+        mapper = object_mapper(instance)
+        prop = mapper.get_property(self.attr.key, resolve_synonyms=True)
+        self._criterion = prop.compare(
+                            operators.eq, 
+                            instance, 
+                            value_is_parent=True, 
+                            alias_secondary=False)
+
+        if self.attr.order_by:
+            self._order_by = self.attr.order_by
+
+    def __session(self):
+        sess = object_session(self.instance)
+        if sess is not None and self.autoflush and sess.autoflush \
+            and self.instance in sess:
+            sess.flush()
+        if not has_identity(self.instance):
+            return None
+        else:
+            return sess
+
+    def session(self):
+        return self.__session()
+    session = property(session, lambda s, x:None)
+
+    def __iter__(self):
+        sess = self.__session()
+        if sess is None:
+            return iter(self.attr._get_collection_history(
+                attributes.instance_state(self.instance),
+                passive=True).added_items)
+        else:
+            return iter(self._clone(sess))
+
+    def __getitem__(self, index):
+        sess = self.__session()
+        if sess is None:
+            return self.attr._get_collection_history(
+                attributes.instance_state(self.instance),
+                passive=True).added_items.__getitem__(index)
+        else:
+            return self._clone(sess).__getitem__(index)
+
+    def count(self):
+        sess = self.__session()
+        if sess is None:
+            return len(self.attr._get_collection_history(
+                attributes.instance_state(self.instance),
+                passive=True).added_items)
+        else:
+            return self._clone(sess).count()
+
+    def _clone(self, sess=None):
+        # note we're returning an entirely new Query class instance
+        # here without any assignment capabilities; the class of this
+        # query is determined by the session.
+        instance = self.instance
+        if sess is None:
+            sess = object_session(instance)
+            if sess is None:
+                raise orm_exc.DetachedInstanceError(
+                    "Parent instance %s is not bound to a Session, and no "
+                    "contextual session is established; lazy load operation "
+                    "of attribute '%s' cannot proceed" % (
+                        mapperutil.instance_str(instance), self.attr.key))
+
+        if self.query_class:
+            query = self.query_class(self.attr.target_mapper, session=sess)
+        else:
+            query = sess.query(self.attr.target_mapper)
+
+        query._criterion = self._criterion
+        query._order_by = self._order_by
+
+        return query
+
+    def append(self, item):
+        self.attr.append(
+            attributes.instance_state(self.instance), 
+            attributes.instance_dict(self.instance), item, None)
+
+    def remove(self, item):
+        self.attr.remove(
+            attributes.instance_state(self.instance), 
+            attributes.instance_dict(self.instance), item, None)
+
+
+class AppenderQuery(AppenderMixin, Query):
+    """A dynamic query that supports basic collection storage operations."""
+
+
+def mixin_user_query(cls):
+    """Return a new class with AppenderQuery functionality layered over."""
+    name = 'Appender' + cls.__name__
+    return type(name, (AppenderMixin, cls), {'query_class': cls})
+
+class CollectionHistory(object):
+    """Overrides AttributeHistory to receive append/remove events directly."""
+
+    def __init__(self, attr, state, apply_to=None):
+        if apply_to:
+            deleted = util.IdentitySet(apply_to.deleted_items)
+            added = apply_to.added_items
+            coll = AppenderQuery(attr, state).autoflush(False)
+            self.unchanged_items = [o for o in util.IdentitySet(coll)
+                                    if o not in deleted]
+            self.added_items = apply_to.added_items
+            self.deleted_items = apply_to.deleted_items
+        else:
+            self.deleted_items = []
+            self.added_items = []
+            self.unchanged_items = []
+

libs/sqlalchemy/orm/evaluator.py

@@ -0,0 +1,111 @@
+# orm/evaluator.py
+# Copyright (C) 2005-2011 the SQLAlchemy authors and contributors <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+import operator
+from sqlalchemy.sql import operators, functions
+from sqlalchemy.sql import expression as sql
+
+
+class UnevaluatableError(Exception):
+    pass
+
+_straight_ops = set(getattr(operators, op)
+                    for op in ('add', 'mul', 'sub', 
+                                # Py2K
+                                'div',
+                                # end Py2K 
+                                'mod', 'truediv',
+                               'lt', 'le', 'ne', 'gt', 'ge', 'eq'))
+
+
+_notimplemented_ops = set(getattr(operators, op)
+                          for op in ('like_op', 'notlike_op', 'ilike_op',
+                                     'notilike_op', 'between_op', 'in_op',
+                                     'notin_op', 'endswith_op', 'concat_op'))
+
+class EvaluatorCompiler(object):
+    def process(self, clause):
+        meth = getattr(self, "visit_%s" % clause.__visit_name__, None)
+        if not meth:
+            raise UnevaluatableError("Cannot evaluate %s" % type(clause).__name__)
+        return meth(clause)
+
+    def visit_grouping(self, clause):
+        return self.process(clause.element)
+
+    def visit_null(self, clause):
+        return lambda obj: None
+
+    def visit_column(self, clause):
+        if 'parentmapper' in clause._annotations:
+            key = clause._annotations['parentmapper'].\
+              _columntoproperty[clause].key
+        else:
+            key = clause.key
+        get_corresponding_attr = operator.attrgetter(key)
+        return lambda obj: get_corresponding_attr(obj)
+
+    def visit_clauselist(self, clause):
+        evaluators = map(self.process, clause.clauses)
+        if clause.operator is operators.or_:
+            def evaluate(obj):
+                has_null = False
+                for sub_evaluate in evaluators:
+                    value = sub_evaluate(obj)
+                    if value:
+                        return True
+                    has_null = has_null or value is None
+                if has_null:
+                    return None
+                return False
+        elif clause.operator is operators.and_:
+            def evaluate(obj):
+                for sub_evaluate in evaluators:
+                    value = sub_evaluate(obj)
+                    if not value:
+                        if value is None:
+                            return None
+                        return False
+                return True
+        else:
+            raise UnevaluatableError("Cannot evaluate clauselist with operator %s" % clause.operator)
+
+        return evaluate
+
+    def visit_binary(self, clause):
+        eval_left,eval_right = map(self.process, [clause.left, clause.right])
+        operator = clause.operator
+        if operator is operators.is_:
+            def evaluate(obj):
+                return eval_left(obj) == eval_right(obj)
+        elif operator is operators.isnot:
+            def evaluate(obj):
+                return eval_left(obj) != eval_right(obj)
+        elif operator in _straight_ops:
+            def evaluate(obj):
+                left_val = eval_left(obj)
+                right_val = eval_right(obj)
+                if left_val is None or right_val is None:
+                    return None
+                return operator(eval_left(obj), eval_right(obj))
+        else:
+            raise UnevaluatableError("Cannot evaluate %s with operator %s" % (type(clause).__name__, clause.operator))
+        return evaluate
+
+    def visit_unary(self, clause):
+        eval_inner = self.process(clause.element)
+        if clause.operator is operators.inv:
+            def evaluate(obj):
+                value = eval_inner(obj)
+                if value is None:
+                    return None
+                return not value
+            return evaluate
+        raise UnevaluatableError("Cannot evaluate %s with operator %s" % (type(clause).__name__, clause.operator))
+
+    def visit_bindparam(self, clause):
+        val = clause.value
+        return lambda obj: val

libs/sqlalchemy/orm/exc.py

@@ -0,0 +1,116 @@
+# orm/exc.py
+# Copyright (C) 2005-2011 the SQLAlchemy authors and contributors <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""SQLAlchemy ORM exceptions."""
+
+import sqlalchemy as sa
+
+
+NO_STATE = (AttributeError, KeyError)
+"""Exception types that may be raised by instrumentation implementations."""
+
+class StaleDataError(sa.exc.SQLAlchemyError):
+    """An operation encountered database state that is unaccounted for.
+
+    Two conditions cause this to happen:
+
+    * A flush may have attempted to update or delete rows
+      and an unexpected number of rows were matched during 
+      the UPDATE or DELETE statement.   Note that when 
+      version_id_col is used, rows in UPDATE or DELETE statements
+      are also matched against the current known version
+      identifier.
+
+    * A mapped object with version_id_col was refreshed, 
+      and the version number coming back from the database does
+      not match that of the object itself.
+
+    """
+
+ConcurrentModificationError = StaleDataError
+
+
+class FlushError(sa.exc.SQLAlchemyError):
+    """A invalid condition was detected during flush()."""
+
+
+class UnmappedError(sa.exc.InvalidRequestError):
+    """Base for exceptions that involve expected mappings not present."""
+
+class DetachedInstanceError(sa.exc.SQLAlchemyError):
+    """An attempt to access unloaded attributes on a 
+    mapped instance that is detached."""
+
+class UnmappedInstanceError(UnmappedError):
+    """An mapping operation was requested for an unknown instance."""
+
+    def __init__(self, obj, msg=None):
+        if not msg:
+            try:
+                mapper = sa.orm.class_mapper(type(obj))
+                name = _safe_cls_name(type(obj))
+                msg = ("Class %r is mapped, but this instance lacks "
+                       "instrumentation.  This occurs when the instance is created "
+                       "before sqlalchemy.orm.mapper(%s) was called." % (name, name))
+            except UnmappedClassError:
+                msg = _default_unmapped(type(obj))
+                if isinstance(obj, type):
+                    msg += (
+                        '; was a class (%s) supplied where an instance was '
+                        'required?' % _safe_cls_name(obj))
+        UnmappedError.__init__(self, msg)
+
+
+class UnmappedClassError(UnmappedError):
+    """An mapping operation was requested for an unknown class."""
+
+    def __init__(self, cls, msg=None):
+        if not msg:
+            msg = _default_unmapped(cls)
+        UnmappedError.__init__(self, msg)
+
+
+class ObjectDeletedError(sa.exc.InvalidRequestError):
+    """An refresh() operation failed to re-retrieve an object's row."""
+
+
+class UnmappedColumnError(sa.exc.InvalidRequestError):
+    """Mapping operation was requested on an unknown column."""
+
+
+class NoResultFound(sa.exc.InvalidRequestError):
+    """A database result was required but none was found."""
+
+
+class MultipleResultsFound(sa.exc.InvalidRequestError):
+    """A single database result was required but more than one were found."""
+
+
+# Legacy compat until 0.6.
+sa.exc.ConcurrentModificationError = ConcurrentModificationError
+sa.exc.FlushError = FlushError
+sa.exc.UnmappedColumnError
+
+def _safe_cls_name(cls):
+    try:
+        cls_name = '.'.join((cls.__module__, cls.__name__))
+    except AttributeError:
+        cls_name = getattr(cls, '__name__', None)
+        if cls_name is None:
+            cls_name = repr(cls)
+    return cls_name
+
+def _default_unmapped(cls):
+    try:
+        mappers = sa.orm.attributes.manager_of_class(cls).mappers
+    except NO_STATE:
+        mappers = {}
+    except TypeError:
+        mappers = {}
+    name = _safe_cls_name(cls)
+
+    if not mappers:
+        return "Class '%s' is not mapped" % name

libs/sqlalchemy/orm/identity.py

@@ -0,0 +1,272 @@
+# orm/identity.py
+# Copyright (C) 2005-2011 the SQLAlchemy authors and contributors <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+import weakref
+
+from sqlalchemy import util as base_util
+from sqlalchemy.orm import attributes
+
+
+class IdentityMap(dict):
+    def __init__(self):
+        self._mutable_attrs = set()
+        self._modified = set()
+        self._wr = weakref.ref(self)
+
+    def replace(self, state):
+        raise NotImplementedError()
+
+    def add(self, state):
+        raise NotImplementedError()
+
+    def remove(self, state):
+        raise NotImplementedError()
+
+    def update(self, dict):
+        raise NotImplementedError("IdentityMap uses add() to insert data")
+
+    def clear(self):
+        raise NotImplementedError("IdentityMap uses remove() to remove data")
+
+    def _manage_incoming_state(self, state):
+        state._instance_dict = self._wr
+
+        if state.modified:
+            self._modified.add(state)
+        if state.manager.mutable_attributes:
+            self._mutable_attrs.add(state)
+
+    def _manage_removed_state(self, state):
+        del state._instance_dict
+        self._mutable_attrs.discard(state)
+        self._modified.discard(state)
+
+    def _dirty_states(self):
+        return self._modified.union(s for s in self._mutable_attrs.copy()
+                                    if s.modified)
+
+    def check_modified(self):
+        """return True if any InstanceStates present have been marked as 'modified'."""
+
+        if self._modified:
+            return True
+        else:
+            for state in self._mutable_attrs.copy():
+                if state.modified:
+                    return True
+        return False
+
+    def has_key(self, key):
+        return key in self
+
+    def popitem(self):
+        raise NotImplementedError("IdentityMap uses remove() to remove data")
+
+    def pop(self, key, *args):
+        raise NotImplementedError("IdentityMap uses remove() to remove data")
+
+    def setdefault(self, key, default=None):
+        raise NotImplementedError("IdentityMap uses add() to insert data")
+
+    def copy(self):
+        raise NotImplementedError()
+
+    def __setitem__(self, key, value):
+        raise NotImplementedError("IdentityMap uses add() to insert data")
+
+    def __delitem__(self, key):
+        raise NotImplementedError("IdentityMap uses remove() to remove data")
+
+class WeakInstanceDict(IdentityMap):
+    def __init__(self):
+        IdentityMap.__init__(self)
+        self._remove_mutex = base_util.threading.Lock()
+
+    def __getitem__(self, key):
+        state = dict.__getitem__(self, key)
+        o = state.obj()
+        if o is None:
+            o = state._is_really_none()
+        if o is None:
+            raise KeyError, key
+        return o
+
+    def __contains__(self, key):
+        try:
+            if dict.__contains__(self, key):
+                state = dict.__getitem__(self, key)
+                o = state.obj()
+                if o is None:
+                    o = state._is_really_none()
+            else:
+                return False
+        except KeyError:
+            return False
+        else:
+            return o is not None
+
+    def contains_state(self, state):
+        return dict.get(self, state.key) is state
+
+    def replace(self, state):
+        if dict.__contains__(self, state.key):
+            existing = dict.__getitem__(self, state.key)
+            if existing is not state:
+                self._manage_removed_state(existing)
+            else:
+                return
+
+        dict.__setitem__(self, state.key, state)
+        self._manage_incoming_state(state)
+
+    def add(self, state):
+        if state.key in self:
+            if dict.__getitem__(self, state.key) is not state:
+                raise AssertionError("A conflicting state is already "
+                                    "present in the identity map for key %r" 
+                                    % (state.key, ))
+        else:
+            dict.__setitem__(self, state.key, state)
+            self._manage_incoming_state(state)
+
+    def remove_key(self, key):
+        state = dict.__getitem__(self, key)
+        self.remove(state)
+
+    def remove(self, state):
+        self._remove_mutex.acquire()
+        try:
+            if dict.pop(self, state.key) is not state:
+                raise AssertionError("State %s is not present in this identity map" % state)
+        finally:
+            self._remove_mutex.release()
+
+        self._manage_removed_state(state)
+
+    def discard(self, state):
+        if self.contains_state(state):
+            dict.__delitem__(self, state.key)
+            self._manage_removed_state(state)
+
+    def get(self, key, default=None):
+        state = dict.get(self, key, default)
+        if state is default:
+            return default
+        o = state.obj()
+        if o is None:
+            o = state._is_really_none()
+        if o is None:
+            return default
+        return o
+
+
+    def items(self):
+    # Py2K
+        return list(self.iteritems())
+
+    def iteritems(self):
+    # end Py2K
+        self._remove_mutex.acquire()
+        try:
+            result = []
+            for state in dict.values(self):
+                value = state.obj()
+                if value is not None:
+                    result.append((state.key, value))
+
+            return iter(result)
+        finally:
+            self._remove_mutex.release()
+
+    def values(self):
+    # Py2K
+        return list(self.itervalues())
+
+    def itervalues(self):
+    # end Py2K
+        self._remove_mutex.acquire()
+        try:
+            result = []
+            for state in dict.values(self):
+                value = state.obj()
+                if value is not None:
+                    result.append(value)
+
+            return iter(result)
+        finally:
+            self._remove_mutex.release()
+
+    def all_states(self):
+        self._remove_mutex.acquire()
+        try:
+            # Py3K
+            # return list(dict.values(self))
+
+            # Py2K
+            return dict.values(self)
+            # end Py2K
+        finally:
+            self._remove_mutex.release()
+
+    def prune(self):
+        return 0
+
+class StrongInstanceDict(IdentityMap):
+    def all_states(self):
+        return [attributes.instance_state(o) for o in self.itervalues()]
+
+    def contains_state(self, state):
+        return state.key in self and attributes.instance_state(self[state.key]) is state
+
+    def replace(self, state):
+        if dict.__contains__(self, state.key):
+            existing = dict.__getitem__(self, state.key)
+            existing = attributes.instance_state(existing)
+            if existing is not state:
+                self._manage_removed_state(existing)
+            else:
+                return
+
+        dict.__setitem__(self, state.key, state.obj())
+        self._manage_incoming_state(state)
+
+    def add(self, state):
+        if state.key in self:
+            if attributes.instance_state(dict.__getitem__(self, state.key)) is not state:
+                raise AssertionError("A conflicting state is already present in the identity map for key %r" % (state.key, ))
+        else:
+            dict.__setitem__(self, state.key, state.obj())
+            self._manage_incoming_state(state)
+
+    def remove(self, state):
+        if attributes.instance_state(dict.pop(self, state.key)) is not state:
+            raise AssertionError("State %s is not present in this identity map" % state)
+        self._manage_removed_state(state)
+
+    def discard(self, state):
+        if self.contains_state(state):
+            dict.__delitem__(self, state.key)
+            self._manage_removed_state(state)
+
+    def remove_key(self, key):
+        state = attributes.instance_state(dict.__getitem__(self, key))
+        self.remove(state)
+
+    def prune(self):
+        """prune unreferenced, non-dirty states."""
+
+        ref_count = len(self)
+        dirty = [s.obj() for s in self.all_states() if s.modified]
+
+        # work around http://bugs.python.org/issue6149
+        keepers = weakref.WeakValueDictionary()
+        keepers.update(self)
+
+        dict.clear(self)
+        dict.update(self, keepers)
+        self.modified = bool(dirty)
+        return ref_count - len(self)
+

libs/sqlalchemy/orm/scoping.py

@@ -0,0 +1,215 @@
+# orm/scoping.py
+# Copyright (C) 2005-2011 the SQLAlchemy authors and contributors <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+import sqlalchemy.exceptions as sa_exc
+from sqlalchemy.util import ScopedRegistry, ThreadLocalRegistry, \
+                            to_list, get_cls_kwargs, deprecated,\
+                            warn
+from sqlalchemy.orm import (
+    EXT_CONTINUE, MapperExtension, class_mapper, object_session
+    )
+from sqlalchemy.orm import exc as orm_exc
+from sqlalchemy.orm.session import Session
+
+
+__all__ = ['ScopedSession']
+
+
+class ScopedSession(object):
+    """Provides thread-local management of Sessions.
+
+    Usage::
+
+      Session = scoped_session(sessionmaker())
+
+    ... use Session normally.
+
+    The internal registry is accessible as well,
+    and by default is an instance of :class:`.ThreadLocalRegistry`.
+
+
+    """
+
+    def __init__(self, session_factory, scopefunc=None):
+        self.session_factory = session_factory
+        if scopefunc:
+            self.registry = ScopedRegistry(session_factory, scopefunc)
+        else:
+            self.registry = ThreadLocalRegistry(session_factory)
+        self.extension = _ScopedExt(self)
+
+    def __call__(self, **kwargs):
+        if kwargs:
+            scope = kwargs.pop('scope', False)
+            if scope is not None:
+                if self.registry.has():
+                    raise sa_exc.InvalidRequestError("Scoped session is already present; "
+                                                    "no new arguments may be specified.")
+                else:
+                    sess = self.session_factory(**kwargs)
+                    self.registry.set(sess)
+                    return sess
+            else:
+                return self.session_factory(**kwargs)
+        else:
+            return self.registry()
+
+    def remove(self):
+        """Dispose of the current contextual session."""
+
+        if self.registry.has():
+            self.registry().close()
+        self.registry.clear()
+
+    @deprecated("0.5", ":meth:`.ScopedSession.mapper` is deprecated.  "
+        "Please see http://www.sqlalchemy.org/trac/wiki/UsageRecipes/SessionAwareMapper "
+        "for information on how to replicate its behavior.")
+    def mapper(self, *args, **kwargs):
+        """return a :func:`.mapper` function which associates this ScopedSession with the Mapper.
+
+        """
+
+        from sqlalchemy.orm import mapper
+
+        extension_args = dict((arg, kwargs.pop(arg))
+                              for arg in get_cls_kwargs(_ScopedExt)
+                              if arg in kwargs)
+
+        kwargs['extension'] = extension = to_list(kwargs.get('extension', []))
+        if extension_args:
+            extension.append(self.extension.configure(**extension_args))
+        else:
+            extension.append(self.extension)
+        return mapper(*args, **kwargs)
+
+    def configure(self, **kwargs):
+        """reconfigure the sessionmaker used by this ScopedSession."""
+
+        if self.registry.has():
+            warn('At least one scoped session is already present. '
+                      ' configure() can not affect sessions that have '
+                      'already been created.')
+
+        self.session_factory.configure(**kwargs)
+
+    def query_property(self, query_cls=None):
+        """return a class property which produces a `Query` object against the
+        class when called.
+
+        e.g.::
+
+            Session = scoped_session(sessionmaker())
+
+            class MyClass(object):
+                query = Session.query_property()
+
+            # after mappers are defined
+            result = MyClass.query.filter(MyClass.name=='foo').all()
+
+        Produces instances of the session's configured query class by
+        default.  To override and use a custom implementation, provide
+        a ``query_cls`` callable.  The callable will be invoked with
+        the class's mapper as a positional argument and a session
+        keyword argument.
+
+        There is no limit to the number of query properties placed on
+        a class.
+
+        """
+        class query(object):
+            def __get__(s, instance, owner):
+                try:
+                    mapper = class_mapper(owner)
+                    if mapper:
+                        if query_cls:
+                            # custom query class
+                            return query_cls(mapper, session=self.registry())
+                        else:
+                            # session's configured query class
+                            return self.registry().query(mapper)
+                except orm_exc.UnmappedClassError:
+                    return None
+        return query()
+
+def instrument(name):
+    def do(self, *args, **kwargs):
+        return getattr(self.registry(), name)(*args, **kwargs)
+    return do
+for meth in Session.public_methods:
+    setattr(ScopedSession, meth, instrument(meth))
+
+def makeprop(name):
+    def set(self, attr):
+        setattr(self.registry(), name, attr)
+    def get(self):
+        return getattr(self.registry(), name)
+    return property(get, set)
+for prop in ('bind', 'dirty', 'deleted', 'new', 'identity_map', 'is_active', 'autoflush'):
+    setattr(ScopedSession, prop, makeprop(prop))
+
+def clslevel(name):
+    def do(cls, *args, **kwargs):
+        return getattr(Session, name)(*args, **kwargs)
+    return classmethod(do)
+for prop in ('close_all', 'object_session', 'identity_key'):
+    setattr(ScopedSession, prop, clslevel(prop))
+
+class _ScopedExt(MapperExtension):
+    def __init__(self, context, validate=False, save_on_init=True):
+        self.context = context
+        self.validate = validate
+        self.save_on_init = save_on_init
+        self.set_kwargs_on_init = True
+
+    def validating(self):
+        return _ScopedExt(self.context, validate=True)
+
+    def configure(self, **kwargs):
+        return _ScopedExt(self.context, **kwargs)
+
+    def instrument_class(self, mapper, class_):
+        class query(object):
+            def __getattr__(s, key):
+                return getattr(self.context.registry().query(class_), key)
+            def __call__(s):
+                return self.context.registry().query(class_)
+            def __get__(self, instance, cls):
+                return self
+
+        if not 'query' in class_.__dict__:
+            class_.query = query()
+
+        if self.set_kwargs_on_init and class_.__init__ is object.__init__:
+            class_.__init__ = self._default__init__(mapper)
+
+    def _default__init__(ext, mapper):
+        def __init__(self, **kwargs):
+            for key, value in kwargs.iteritems():
+                if ext.validate:
+                    if not mapper.get_property(key, resolve_synonyms=False,
+                                               raiseerr=False):
+                        raise sa_exc.ArgumentError(
+                            "Invalid __init__ argument: '%s'" % key)
+                setattr(self, key, value)
+        return __init__
+
+    def init_instance(self, mapper, class_, oldinit, instance, args, kwargs):
+        if self.save_on_init:
+            session = kwargs.pop('_sa_session', None)
+            if session is None:
+                session = self.context.registry()
+            session._save_without_cascade(instance)
+        return EXT_CONTINUE
+
+    def init_failed(self, mapper, class_, oldinit, instance, args, kwargs):
+        sess = object_session(instance)
+        if sess:
+            sess.expunge(instance)
+        return EXT_CONTINUE
+
+    def dispose_class(self, mapper, class_):
+        if hasattr(class_, 'query'):
+            delattr(class_, 'query')

libs/sqlalchemy/orm/shard.py

@@ -0,0 +1,15 @@
+# orm/shard.py
+# Copyright (C) 2005-2011 the SQLAlchemy authors and contributors <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+from sqlalchemy import util
+
+util.warn_deprecated(
+    "Horizontal sharding is now importable via "
+    "'import sqlalchemy.ext.horizontal_shard"
+)
+
+from sqlalchemy.ext.horizontal_shard import *
+

libs/sqlalchemy/orm/state.py

@@ -0,0 +1,549 @@
+# orm/state.py
+# Copyright (C) 2005-2011 the SQLAlchemy authors and contributors <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+from sqlalchemy.util import EMPTY_SET
+import weakref
+from sqlalchemy import util
+from sqlalchemy.orm.attributes import PASSIVE_NO_RESULT, PASSIVE_OFF, \
+                                        NEVER_SET, NO_VALUE, manager_of_class, \
+                                        ATTR_WAS_SET
+from sqlalchemy.orm import attributes, exc as orm_exc, interfaces
+
+import sys
+attributes.state = sys.modules['sqlalchemy.orm.state']
+
+class InstanceState(object):
+    """tracks state information at the instance level."""
+
+    session_id = None
+    key = None
+    runid = None
+    load_options = EMPTY_SET
+    load_path = ()
+    insert_order = None
+    mutable_dict = None
+    _strong_obj = None
+    modified = False
+    expired = False
+    deleted = False
+
+    def __init__(self, obj, manager):
+        self.class_ = obj.__class__
+        self.manager = manager
+        self.obj = weakref.ref(obj, self._cleanup)
+
+    @util.memoized_property
+    def committed_state(self):
+        return {}
+
+    @util.memoized_property
+    def parents(self):
+        return {}
+
+    @util.memoized_property
+    def pending(self):
+        return {}
+
+    @util.memoized_property
+    def callables(self):
+        return {}
+
+    @property
+    def has_identity(self):
+        return bool(self.key)
+
+    def detach(self):
+        if self.session_id:
+            try:
+                del self.session_id
+            except AttributeError:
+                pass
+
+    def dispose(self):
+        self.detach()
+        del self.obj
+
+    def _cleanup(self, ref):
+        instance_dict = self._instance_dict()
+        if instance_dict:
+            try:
+                instance_dict.remove(self)
+            except AssertionError:
+                pass
+        # remove possible cycles
+        self.__dict__.pop('callables', None)
+        self.dispose()
+
+    def obj(self):
+        return None
+
+    @property
+    def dict(self):
+        o = self.obj()
+        if o is not None:
+            return attributes.instance_dict(o)
+        else:
+            return {}
+
+    @property
+    def sort_key(self):
+        return self.key and self.key[1] or (self.insert_order, )
+
+    def initialize_instance(*mixed, **kwargs):
+        self, instance, args = mixed[0], mixed[1], mixed[2:]
+        manager = self.manager
+
+        for fn in manager.events.on_init:
+            fn(self, instance, args, kwargs)
+
+        # LESSTHANIDEAL:
+        # adjust for the case where the InstanceState was created before
+        # mapper compilation, and this actually needs to be a MutableAttrInstanceState
+        if manager.mutable_attributes and self.__class__ is not MutableAttrInstanceState:
+            self.__class__ = MutableAttrInstanceState
+            self.obj = weakref.ref(self.obj(), self._cleanup)
+            self.mutable_dict = {}
+
+        try:
+            return manager.events.original_init(*mixed[1:], **kwargs)
+        except:
+            for fn in manager.events.on_init_failure:
+                fn(self, instance, args, kwargs)
+            raise
+
+    def get_history(self, key, **kwargs):
+        return self.manager.get_impl(key).get_history(self, self.dict, **kwargs)
+
+    def get_impl(self, key):
+        return self.manager.get_impl(key)
+
+    def get_pending(self, key):
+        if key not in self.pending:
+            self.pending[key] = PendingCollection()
+        return self.pending[key]
+
+    def value_as_iterable(self, key, passive=PASSIVE_OFF):
+        """return an InstanceState attribute as a list,
+        regardless of it being a scalar or collection-based
+        attribute.
+
+        returns None if passive is not PASSIVE_OFF and the getter returns
+        PASSIVE_NO_RESULT.
+        """
+
+        impl = self.get_impl(key)
+        dict_ = self.dict
+        x = impl.get(self, dict_, passive=passive)
+        if x is PASSIVE_NO_RESULT:
+            return None
+        elif hasattr(impl, 'get_collection'):
+            return impl.get_collection(self, dict_, x, passive=passive)
+        else:
+            return [x]
+
+    def _run_on_load(self, instance):
+        self.manager.events.run('on_load', instance)
+
+    def __getstate__(self):
+        d = {'instance':self.obj()}
+
+        d.update(
+            (k, self.__dict__[k]) for k in (
+                'committed_state', 'pending', 'parents', 'modified', 'expired', 
+                'callables', 'key', 'load_options', 'mutable_dict'
+            ) if k in self.__dict__ 
+        )
+        if self.load_path:
+            d['load_path'] = interfaces.serialize_path(self.load_path)
+        return d
+
+    def __setstate__(self, state):
+        self.obj = weakref.ref(state['instance'], self._cleanup)
+        self.class_ = state['instance'].__class__
+        self.manager = manager = manager_of_class(self.class_)
+        if manager is None:
+            raise orm_exc.UnmappedInstanceError(
+                        state['instance'],
+                        "Cannot deserialize object of type %r - no mapper() has"
+                        " been configured for this class within the current Python process!" %
+                        self.class_)
+        elif manager.is_mapped and not manager.mapper.compiled:
+            manager.mapper.compile()
+
+        self.committed_state = state.get('committed_state', {})
+        self.pending = state.get('pending', {})
+        self.parents = state.get('parents', {})
+        self.modified = state.get('modified', False)
+        self.expired = state.get('expired', False)
+        self.callables = state.get('callables', {})
+
+        if self.modified:
+            self._strong_obj = state['instance']
+
+        self.__dict__.update([
+            (k, state[k]) for k in (
+                'key', 'load_options', 'mutable_dict'
+            ) if k in state 
+        ])
+
+        if 'load_path' in state:
+            self.load_path = interfaces.deserialize_path(state['load_path'])
+
+    def initialize(self, key):
+        """Set this attribute to an empty value or collection, 
+           based on the AttributeImpl in use."""
+
+        self.manager.get_impl(key).initialize(self, self.dict)
+
+    def reset(self, dict_, key):
+        """Remove the given attribute and any 
+           callables associated with it."""
+
+        dict_.pop(key, None)
+        self.callables.pop(key, None)
+
+    def expire_attribute_pre_commit(self, dict_, key):
+        """a fast expire that can be called by column loaders during a load.
+
+        The additional bookkeeping is finished up in commit_all().
+
+        This method is actually called a lot with joined-table
+        loading, when the second table isn't present in the result.
+
+        """
+        dict_.pop(key, None)
+        self.callables[key] = self
+
+    def set_callable(self, dict_, key, callable_):
+        """Remove the given attribute and set the given callable
+           as a loader."""
+
+        dict_.pop(key, None)
+        self.callables[key] = callable_
+
+    def expire_attributes(self, dict_, attribute_names, instance_dict=None):
+        """Expire all or a group of attributes.
+
+        If all attributes are expired, the "expired" flag is set to True.
+
+        """
+        # we would like to assert that 'self.key is not None' here, 
+        # but there are many cases where the mapper will expire
+        # a newly persisted instance within the flush, before the
+        # key is assigned, and even cases where the attribute refresh
+        # occurs fully, within the flush(), before this key is assigned.
+        # the key is assigned late within the flush() to assist in
+        # "key switch" bookkeeping scenarios.
+
+        if attribute_names is None:
+            attribute_names = self.manager.keys()
+            self.expired = True
+            if self.modified:
+                if not instance_dict:
+                    instance_dict = self._instance_dict()
+                    if instance_dict:
+                        instance_dict._modified.discard(self)
+                else:
+                    instance_dict._modified.discard(self)
+
+            self.modified = False
+            filter_deferred = True
+        else:
+            filter_deferred = False
+
+        to_clear = (
+            self.__dict__.get('pending', None),
+            self.__dict__.get('committed_state', None),
+            self.mutable_dict
+        )
+
+        for key in attribute_names:
+            impl = self.manager[key].impl
+            if impl.accepts_scalar_loader and \
+                (not filter_deferred or impl.expire_missing or key in dict_):
+                self.callables[key] = self
+            dict_.pop(key, None)
+
+            for d in to_clear:
+                if d is not None:
+                    d.pop(key, None)
+
+    def __call__(self, **kw):
+        """__call__ allows the InstanceState to act as a deferred
+        callable for loading expired attributes, which is also
+        serializable (picklable).
+
+        """
+
+        if kw.get('passive') is attributes.PASSIVE_NO_FETCH:
+            return attributes.PASSIVE_NO_RESULT
+
+        toload = self.expired_attributes.\
+                        intersection(self.unmodified)
+
+        self.manager.deferred_scalar_loader(self, toload)
+
+        # if the loader failed, or this 
+        # instance state didn't have an identity,
+        # the attributes still might be in the callables
+        # dict.  ensure they are removed.
+        for k in toload.intersection(self.callables):
+            del self.callables[k]
+
+        return ATTR_WAS_SET
+
+    @property
+    def unmodified(self):
+        """Return the set of keys which have no uncommitted changes"""
+
+        return set(self.manager).difference(self.committed_state)
+
+    @property
+    def unloaded(self):
+        """Return the set of keys which do not have a loaded value.
+
+        This includes expired attributes and any other attribute that
+        was never populated or modified.
+
+        """
+        return set(self.manager).\
+                    difference(self.committed_state).\
+                    difference(self.dict)
+
+    @property
+    def expired_attributes(self):
+        """Return the set of keys which are 'expired' to be loaded by
+           the manager's deferred scalar loader, assuming no pending 
+           changes.
+
+           see also the ``unmodified`` collection which is intersected
+           against this set when a refresh operation occurs.
+
+        """
+        return set([k for k, v in self.callables.items() if v is self])
+
+    def _instance_dict(self):
+        return None
+
+    def _is_really_none(self):
+        return self.obj()
+
+    def modified_event(self, dict_, attr, should_copy, previous, passive=PASSIVE_OFF):
+        if attr.key not in self.committed_state:
+            if previous is NEVER_SET:
+                if passive:
+                    if attr.key in dict_:
+                        previous = dict_[attr.key]
+                else:
+                    previous = attr.get(self, dict_)
+
+            if should_copy and previous not in (None, NO_VALUE, NEVER_SET):
+                previous = attr.copy(previous)
+
+            self.committed_state[attr.key] = previous
+
+
+        # the "or not self.modified" is defensive at 
+        # this point.  The assertion below is expected
+        # to be True:
+        # assert self._strong_obj is None or self.modified
+
+        if self._strong_obj is None or not self.modified:
+            instance_dict = self._instance_dict()
+            if instance_dict:
+                instance_dict._modified.add(self)
+
+            self._strong_obj = self.obj()
+
+            self.modified = True
+
+    def commit(self, dict_, keys):
+        """Commit attributes.
+
+        This is used by a partial-attribute load operation to mark committed
+        those attributes which were refreshed from the database.
+
+        Attributes marked as "expired" can potentially remain "expired" after
+        this step if a value was not populated in state.dict.
+
+        """
+        class_manager = self.manager
+        for key in keys:
+            if key in dict_ and key in class_manager.mutable_attributes:
+                self.committed_state[key] = self.manager[key].impl.copy(dict_[key])
+            else:
+                self.committed_state.pop(key, None)
+
+        self.expired = False
+
+        for key in set(self.callables).\
+                            intersection(keys).\
+                            intersection(dict_):
+            del self.callables[key]
+
+    def commit_all(self, dict_, instance_dict=None):
+        """commit all attributes unconditionally.
+
+        This is used after a flush() or a full load/refresh
+        to remove all pending state from the instance.
+
+         - all attributes are marked as "committed"
+         - the "strong dirty reference" is removed
+         - the "modified" flag is set to False
+         - any "expired" markers/callables for attributes loaded are removed.
+
+        Attributes marked as "expired" can potentially remain "expired" after this step
+        if a value was not populated in state.dict.
+
+        """
+
+        self.__dict__.pop('committed_state', None)
+        self.__dict__.pop('pending', None)
+
+        if 'callables' in self.__dict__:
+            callables = self.callables
+            for key in list(callables):
+                if key in dict_ and callables[key] is self:
+                    del callables[key]
+
+        for key in self.manager.mutable_attributes:
+            if key in dict_:
+                self.committed_state[key] = self.manager[key].impl.copy(dict_[key])
+
+        if instance_dict and self.modified:
+            instance_dict._modified.discard(self)
+
+        self.modified = self.expired = False
+        self._strong_obj = None
+
+class MutableAttrInstanceState(InstanceState):
+    """InstanceState implementation for objects that reference 'mutable' 
+    attributes.
+
+    Has a more involved "cleanup" handler that checks mutable attributes
+    for changes upon dereference, resurrecting if needed.
+
+    """
+
+    @util.memoized_property
+    def mutable_dict(self):
+        return {}
+
+    def _get_modified(self, dict_=None):
+        if self.__dict__.get('modified', False):
+            return True
+        else:
+            if dict_ is None:
+                dict_ = self.dict
+            for key in self.manager.mutable_attributes:
+                if self.manager[key].impl.check_mutable_modified(self, dict_):
+                    return True
+            else:
+                return False
+
+    def _set_modified(self, value):
+        self.__dict__['modified'] = value
+
+    modified = property(_get_modified, _set_modified)
+
+    @property
+    def unmodified(self):
+        """a set of keys which have no uncommitted changes"""
+
+        dict_ = self.dict
+
+        return set([
+            key for key in self.manager
+            if (key not in self.committed_state or
+                (key in self.manager.mutable_attributes and
+                 not self.manager[key].impl.check_mutable_modified(self, dict_)))])
+
+    def _is_really_none(self):
+        """do a check modified/resurrect.
+
+        This would be called in the extremely rare
+        race condition that the weakref returned None but
+        the cleanup handler had not yet established the 
+        __resurrect callable as its replacement.
+
+        """
+        if self.modified:
+            self.obj = self.__resurrect
+            return self.obj()
+        else:
+            return None
+
+    def reset(self, dict_, key):
+        self.mutable_dict.pop(key, None)
+        InstanceState.reset(self, dict_, key)
+
+    def _cleanup(self, ref):
+        """weakref callback.
+
+        This method may be called by an asynchronous
+        gc.
+
+        If the state shows pending changes, the weakref
+        is replaced by the __resurrect callable which will
+        re-establish an object reference on next access,
+        else removes this InstanceState from the owning
+        identity map, if any.
+
+        """
+        if self._get_modified(self.mutable_dict):
+            self.obj = self.__resurrect
+        else:
+            instance_dict = self._instance_dict()
+            if instance_dict:
+                try:
+                    instance_dict.remove(self)
+                except AssertionError:
+                    pass
+            self.dispose()
+
+    def __resurrect(self):
+        """A substitute for the obj() weakref function which resurrects."""
+
+        # store strong ref'ed version of the object; will revert
+        # to weakref when changes are persisted
+
+        obj = self.manager.new_instance(state=self)
+        self.obj = weakref.ref(obj, self._cleanup)
+        self._strong_obj = obj
+        obj.__dict__.update(self.mutable_dict)
+
+        # re-establishes identity attributes from the key
+        self.manager.events.run('on_resurrect', self, obj)
+
+        # TODO: don't really think we should run this here.
+        # resurrect is only meant to preserve the minimal state needed to
+        # do an UPDATE, not to produce a fully usable object
+        self._run_on_load(obj)
+
+        return obj
+
+class PendingCollection(object):
+    """A writable placeholder for an unloaded collection.
+
+    Stores items appended to and removed from a collection that has not yet
+    been loaded. When the collection is loaded, the changes stored in
+    PendingCollection are applied to it to produce the final result.
+
+    """
+    def __init__(self):
+        self.deleted_items = util.IdentitySet()
+        self.added_items = util.OrderedIdentitySet()
+
+    def append(self, value):
+        if value in self.deleted_items:
+            self.deleted_items.remove(value)
+        self.added_items.add(value)
+
+    def remove(self, value):
+        if value in self.added_items:
+            self.added_items.remove(value)
+        self.deleted_items.add(value)
+

libs/sqlalchemy/orm/sync.py

@@ -0,0 +1,97 @@
+# orm/sync.py
+# Copyright (C) 2005-2011 the SQLAlchemy authors and contributors <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""private module containing functions used for copying data 
+between instances based on join conditions.
+"""
+
+from sqlalchemy.orm import exc, util as mapperutil
+
+def populate(source, source_mapper, dest, dest_mapper, 
+                        synchronize_pairs, uowcommit, flag_cascaded_pks):
+    for l, r in synchronize_pairs:
+        try:
+            value = source_mapper._get_state_attr_by_column(source, source.dict, l)
+        except exc.UnmappedColumnError:
+            _raise_col_to_prop(False, source_mapper, l, dest_mapper, r)
+
+        try:
+            dest_mapper._set_state_attr_by_column(dest, dest.dict, r, value)
+        except exc.UnmappedColumnError:
+            _raise_col_to_prop(True, source_mapper, l, dest_mapper, r)
+
+        # techically the "r.primary_key" check isn't
+        # needed here, but we check for this condition to limit
+        # how often this logic is invoked for memory/performance
+        # reasons, since we only need this info for a primary key
+        # destination.
+        if l.primary_key and r.primary_key and \
+                    r.references(l) and flag_cascaded_pks:
+            uowcommit.attributes[("pk_cascaded", dest, r)] = True
+
+def clear(dest, dest_mapper, synchronize_pairs):
+    for l, r in synchronize_pairs:
+        if r.primary_key:
+            raise AssertionError(
+                                "Dependency rule tried to blank-out primary key "
+                                "column '%s' on instance '%s'" % 
+                                (r, mapperutil.state_str(dest))
+                            )
+        try:
+            dest_mapper._set_state_attr_by_column(dest, dest.dict, r, None)
+        except exc.UnmappedColumnError:
+            _raise_col_to_prop(True, None, l, dest_mapper, r)
+
+def update(source, source_mapper, dest, old_prefix, synchronize_pairs):
+    for l, r in synchronize_pairs:
+        try:
+            oldvalue = source_mapper._get_committed_attr_by_column(source.obj(), l)
+            value = source_mapper._get_state_attr_by_column(source, source.dict, l)
+        except exc.UnmappedColumnError:
+            _raise_col_to_prop(False, source_mapper, l, None, r)
+        dest[r.key] = value
+        dest[old_prefix + r.key] = oldvalue
+
+def populate_dict(source, source_mapper, dict_, synchronize_pairs):
+    for l, r in synchronize_pairs:
+        try:
+            value = source_mapper._get_state_attr_by_column(source, source.dict, l)
+        except exc.UnmappedColumnError:
+            _raise_col_to_prop(False, source_mapper, l, None, r)
+
+        dict_[r.key] = value
+
+def source_modified(uowcommit, source, source_mapper, synchronize_pairs):
+    """return true if the source object has changes from an old to a 
+    new value on the given synchronize pairs
+
+    """
+    for l, r in synchronize_pairs:
+        try:
+            prop = source_mapper._columntoproperty[l]
+        except exc.UnmappedColumnError:
+            _raise_col_to_prop(False, source_mapper, l, None, r)
+        history = uowcommit.get_attribute_history(source, prop.key, passive=True)
+        return bool(history.deleted)
+    else:
+        return False
+
+def _raise_col_to_prop(isdest, source_mapper, source_column, dest_mapper, dest_column):
+    if isdest:
+        raise exc.UnmappedColumnError(
+                                "Can't execute sync rule for destination column '%s'; "
+                                "mapper '%s' does not map this column.  Try using an explicit"
+                                " `foreign_keys` collection which does not include this column "
+                                "(or use a viewonly=True relation)." % (dest_column, source_mapper)
+                                )
+    else:
+        raise exc.UnmappedColumnError(
+                                "Can't execute sync rule for source column '%s'; mapper '%s' "
+                                "does not map this column.  Try using an explicit `foreign_keys`"
+                                " collection which does not include destination column '%s' (or "
+                                "use a viewonly=True relation)." % 
+                                (source_column, source_mapper, dest_column)
+                                )

libs/sqlalchemy/orm/unitofwork.py

@@ -0,0 +1,558 @@
+# orm/unitofwork.py
+# Copyright (C) 2005-2011 the SQLAlchemy authors and contributors <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""The internals for the unit of work system.
+
+The session's flush() process passes objects to a contextual object
+here, which assembles flush tasks based on mappers and their properties,
+organizes them in order of dependency, and executes.
+
+"""
+
+from sqlalchemy import util, topological
+from sqlalchemy.orm import attributes, interfaces
+from sqlalchemy.orm import util as mapperutil
+from sqlalchemy.orm.util import _state_mapper
+session = util.importlater("sqlalchemy.orm", "session")
+
+class UOWEventHandler(interfaces.AttributeExtension):
+    """An event handler added to all relationship attributes which handles
+    session cascade operations.
+    """
+
+    active_history = False
+
+    def __init__(self, key):
+        self.key = key
+
+    def append(self, state, item, initiator):
+        # process "save_update" cascade rules for when 
+        # an instance is appended to the list of another instance
+
+        sess = session._state_session(state)
+        if sess:
+            prop = _state_mapper(state).get_property(self.key)
+            if prop.cascade.save_update and \
+                (prop.cascade_backrefs or self.key == initiator.key) and \
+                item not in sess:
+                sess.add(item)
+        return item
+
+    def remove(self, state, item, initiator):
+        sess = session._state_session(state)
+        if sess:
+            prop = _state_mapper(state).get_property(self.key)
+            # expunge pending orphans
+            if prop.cascade.delete_orphan and \
+                item in sess.new and \
+                prop.mapper._is_orphan(attributes.instance_state(item)):
+                    sess.expunge(item)
+
+    def set(self, state, newvalue, oldvalue, initiator):
+        # process "save_update" cascade rules for when an instance 
+        # is attached to another instance
+        if oldvalue is newvalue:
+            return newvalue
+
+        sess = session._state_session(state)
+        if sess:
+            prop = _state_mapper(state).get_property(self.key)
+            if newvalue is not None and \
+                prop.cascade.save_update and \
+                (prop.cascade_backrefs or self.key == initiator.key) and \
+                newvalue not in sess:
+                sess.add(newvalue)
+            if prop.cascade.delete_orphan and \
+                oldvalue in sess.new and \
+                prop.mapper._is_orphan(attributes.instance_state(oldvalue)):
+                sess.expunge(oldvalue)
+        return newvalue
+
+
+class UOWTransaction(object):
+    def __init__(self, session):
+        self.session = session
+        self.mapper_flush_opts = session._mapper_flush_opts
+
+        # dictionary used by external actors to 
+        # store arbitrary state information.
+        self.attributes = {}
+
+        # dictionary of mappers to sets of 
+        # DependencyProcessors, which are also 
+        # set to be part of the sorted flush actions,
+        # which have that mapper as a parent.
+        self.deps = util.defaultdict(set)
+
+        # dictionary of mappers to sets of InstanceState
+        # items pending for flush which have that mapper
+        # as a parent.
+        self.mappers = util.defaultdict(set)
+
+        # a dictionary of Preprocess objects, which gather
+        # additional states impacted by the flush
+        # and determine if a flush action is needed
+        self.presort_actions = {}
+
+        # dictionary of PostSortRec objects, each 
+        # one issues work during the flush within
+        # a certain ordering.
+        self.postsort_actions = {}
+
+        # a set of 2-tuples, each containing two
+        # PostSortRec objects where the second
+        # is dependent on the first being executed
+        # first
+        self.dependencies = set()
+
+        # dictionary of InstanceState-> (isdelete, listonly)
+        # tuples, indicating if this state is to be deleted
+        # or insert/updated, or just refreshed
+        self.states = {}
+
+        # tracks InstanceStates which will be receiving
+        # a "post update" call.  Keys are mappers,
+        # values are a set of states and a set of the 
+        # columns which should be included in the update.
+        self.post_update_states = util.defaultdict(lambda: (set(), set()))
+
+    @property
+    def has_work(self):
+        return bool(self.states)
+
+    def is_deleted(self, state):
+        """return true if the given state is marked as deleted 
+        within this uowtransaction."""
+
+        return state in self.states and self.states[state][0]
+
+    def memo(self, key, callable_):
+        if key in self.attributes:
+            return self.attributes[key]
+        else:
+            self.attributes[key] = ret = callable_()
+            return ret
+
+    def remove_state_actions(self, state):
+        """remove pending actions for a state from the uowtransaction."""
+
+        isdelete = self.states[state][0]
+
+        self.states[state] = (isdelete, True)
+
+    def get_attribute_history(self, state, key, passive=attributes.PASSIVE_NO_INITIALIZE):
+        """facade to attributes.get_state_history(), including caching of results."""
+
+        hashkey = ("history", state, key)
+
+        # cache the objects, not the states; the strong reference here
+        # prevents newly loaded objects from being dereferenced during the
+        # flush process
+        if hashkey in self.attributes:
+            (history, cached_passive) = self.attributes[hashkey]
+            # if the cached lookup was "passive" and now we want non-passive, do a non-passive
+            # lookup and re-cache
+            if cached_passive and not passive:
+                history = state.get_history(key, passive=False)
+                self.attributes[hashkey] = (history, passive)
+        else:
+            history = state.get_history(key, passive=passive)
+            self.attributes[hashkey] = (history, passive)
+
+        if not history or not state.get_impl(key).uses_objects:
+            return history
+        else:
+            return history.as_state()
+
+    def has_dep(self, processor):
+        return (processor, True) in self.presort_actions
+
+    def register_preprocessor(self, processor, fromparent):
+        key = (processor, fromparent)
+        if key not in self.presort_actions:
+            self.presort_actions[key] = Preprocess(processor, fromparent)
+
+    def register_object(self, state, isdelete=False, 
+                            listonly=False, cancel_delete=False):
+        if not self.session._contains_state(state):
+            return
+
+        if state not in self.states:
+            mapper = _state_mapper(state)
+
+            if mapper not in self.mappers:
+                mapper._per_mapper_flush_actions(self)
+
+            self.mappers[mapper].add(state)
+            self.states[state] = (isdelete, listonly)
+        else:
+            if not listonly and (isdelete or cancel_delete):
+                self.states[state] = (isdelete, False)
+
+    def issue_post_update(self, state, post_update_cols):
+        mapper = state.manager.mapper.base_mapper
+        states, cols = self.post_update_states[mapper]
+        states.add(state)
+        cols.update(post_update_cols)
+
+    @util.memoized_property
+    def _mapper_for_dep(self):
+        """return a dynamic mapping of (Mapper, DependencyProcessor) to 
+        True or False, indicating if the DependencyProcessor operates 
+        on objects of that Mapper.
+
+        The result is stored in the dictionary persistently once
+        calculated.
+
+        """
+        return util.PopulateDict(
+                    lambda tup:tup[0]._props.get(tup[1].key) is tup[1].prop
+                )
+
+    def filter_states_for_dep(self, dep, states):
+        """Filter the given list of InstanceStates to those relevant to the 
+        given DependencyProcessor.
+
+        """
+        mapper_for_dep = self._mapper_for_dep
+        return [s for s in states if mapper_for_dep[(s.manager.mapper, dep)]]
+
+    def states_for_mapper_hierarchy(self, mapper, isdelete, listonly):
+        checktup = (isdelete, listonly)
+        for mapper in mapper.base_mapper.self_and_descendants:
+            for state in self.mappers[mapper]:
+                if self.states[state] == checktup:
+                    yield state
+
+    def _generate_actions(self):
+        """Generate the full, unsorted collection of PostSortRecs as
+        well as dependency pairs for this UOWTransaction.
+
+        """
+        # execute presort_actions, until all states
+        # have been processed.   a presort_action might
+        # add new states to the uow.
+        while True:
+            ret = False
+            for action in list(self.presort_actions.values()):
+                if action.execute(self):
+                    ret = True
+            if not ret:
+                break
+
+        # see if the graph of mapper dependencies has cycles.
+        self.cycles = cycles = topological.find_cycles(
+                                        self.dependencies, 
+                                        self.postsort_actions.values())
+
+        if cycles:
+            # if yes, break the per-mapper actions into
+            # per-state actions
+            convert = dict(
+                (rec, set(rec.per_state_flush_actions(self)))
+                for rec in cycles
+            )
+
+            # rewrite the existing dependencies to point to
+            # the per-state actions for those per-mapper actions
+            # that were broken up.
+            for edge in list(self.dependencies):
+                if None in edge or \
+                    edge[0].disabled or edge[1].disabled or \
+                    cycles.issuperset(edge):
+                    self.dependencies.remove(edge)
+                elif edge[0] in cycles:
+                    self.dependencies.remove(edge)
+                    for dep in convert[edge[0]]:
+                        self.dependencies.add((dep, edge[1]))
+                elif edge[1] in cycles:
+                    self.dependencies.remove(edge)
+                    for dep in convert[edge[1]]:
+                        self.dependencies.add((edge[0], dep))
+
+        return set([a for a in self.postsort_actions.values()
+                    if not a.disabled
+                    ]
+                ).difference(cycles)
+
+    def execute(self):
+        postsort_actions = self._generate_actions()
+
+        #sort = topological.sort(self.dependencies, postsort_actions)
+        #print "--------------"
+        #print self.dependencies
+        #print list(sort)
+        #print "COUNT OF POSTSORT ACTIONS", len(postsort_actions)
+
+        # execute
+        if self.cycles:
+            for set_ in topological.sort_as_subsets(
+                                            self.dependencies, 
+                                            postsort_actions):
+                while set_:
+                    n = set_.pop()
+                    n.execute_aggregate(self, set_)
+        else:
+            for rec in topological.sort(
+                                    self.dependencies, 
+                                    postsort_actions):
+                rec.execute(self)
+
+
+    def finalize_flush_changes(self):
+        """mark processed objects as clean / deleted after a successful flush().
+
+        this method is called within the flush() method after the
+        execute() method has succeeded and the transaction has been committed.
+
+        """
+        for state, (isdelete, listonly) in self.states.iteritems():
+            if isdelete:
+                self.session._remove_newly_deleted(state)
+            else:
+                # if listonly:
+                #   debug... would like to see how many do this
+                self.session._register_newly_persistent(state)
+
+class IterateMappersMixin(object):
+    def _mappers(self, uow):
+        if self.fromparent:
+            return iter(
+                m for m in self.dependency_processor.parent.self_and_descendants
+                if uow._mapper_for_dep[(m, self.dependency_processor)]
+            )
+        else:
+            return self.dependency_processor.mapper.self_and_descendants
+
+class Preprocess(IterateMappersMixin):
+    def __init__(self, dependency_processor, fromparent):
+        self.dependency_processor = dependency_processor
+        self.fromparent = fromparent
+        self.processed = set()
+        self.setup_flush_actions = False
+
+    def execute(self, uow):
+        delete_states = set()
+        save_states = set()
+
+        for mapper in self._mappers(uow):
+            for state in uow.mappers[mapper].difference(self.processed):
+                (isdelete, listonly) = uow.states[state]
+                if not listonly:
+                    if isdelete:
+                        delete_states.add(state)
+                    else:
+                        save_states.add(state)
+
+        if delete_states:
+            self.dependency_processor.presort_deletes(uow, delete_states)
+            self.processed.update(delete_states)
+        if save_states:
+            self.dependency_processor.presort_saves(uow, save_states)
+            self.processed.update(save_states)
+
+        if (delete_states or save_states):
+            if not self.setup_flush_actions and (
+                    self.dependency_processor.\
+                            prop_has_changes(uow, delete_states, True) or
+                    self.dependency_processor.\
+                            prop_has_changes(uow, save_states, False)
+                ):
+                self.dependency_processor.per_property_flush_actions(uow)
+                self.setup_flush_actions = True
+            return True
+        else:
+            return False
+
+class PostSortRec(object):
+    disabled = False
+
+    def __new__(cls, uow, *args):
+        key = (cls, ) + args
+        if key in uow.postsort_actions:
+            return uow.postsort_actions[key]
+        else:
+            uow.postsort_actions[key] = \
+                                    ret = \
+                                    object.__new__(cls)
+            return ret
+
+    def execute_aggregate(self, uow, recs):
+        self.execute(uow)
+
+    def __repr__(self):
+        return "%s(%s)" % (
+            self.__class__.__name__,
+            ",".join(str(x) for x in self.__dict__.values())
+        )
+
+class ProcessAll(IterateMappersMixin, PostSortRec):
+    def __init__(self, uow, dependency_processor, delete, fromparent):
+        self.dependency_processor = dependency_processor
+        self.delete = delete
+        self.fromparent = fromparent
+        uow.deps[dependency_processor.parent.base_mapper].add(dependency_processor)
+
+    def execute(self, uow):
+        states = self._elements(uow)
+        if self.delete:
+            self.dependency_processor.process_deletes(uow, states)
+        else:
+            self.dependency_processor.process_saves(uow, states)
+
+    def per_state_flush_actions(self, uow):
+        # this is handled by SaveUpdateAll and DeleteAll,
+        # since a ProcessAll should unconditionally be pulled
+        # into per-state if either the parent/child mappers
+        # are part of a cycle
+        return iter([])
+
+    def __repr__(self):
+        return "%s(%s, delete=%s)" % (
+            self.__class__.__name__,
+            self.dependency_processor,
+            self.delete
+        )
+
+    def _elements(self, uow):
+        for mapper in self._mappers(uow):
+            for state in uow.mappers[mapper]:
+                (isdelete, listonly) = uow.states[state]
+                if isdelete == self.delete and not listonly:
+                    yield state
+
+class IssuePostUpdate(PostSortRec):
+    def __init__(self, uow, mapper, isdelete):
+        self.mapper = mapper
+        self.isdelete = isdelete
+
+    def execute(self, uow):
+        states, cols = uow.post_update_states[self.mapper]
+        states = [s for s in states if uow.states[s][0] == self.isdelete]
+
+        self.mapper._post_update(states, uow, cols)
+
+class SaveUpdateAll(PostSortRec):
+    def __init__(self, uow, mapper):
+        self.mapper = mapper
+        assert mapper is mapper.base_mapper
+
+    def execute(self, uow):
+        self.mapper._save_obj(
+            uow.states_for_mapper_hierarchy(self.mapper, False, False),
+            uow
+        )
+
+    def per_state_flush_actions(self, uow):
+        states = list(uow.states_for_mapper_hierarchy(self.mapper, False, False))
+        for rec in self.mapper._per_state_flush_actions(
+                            uow, 
+                            states, 
+                            False):
+            yield rec
+
+        for dep in uow.deps[self.mapper]:
+            states_for_prop = uow.filter_states_for_dep(dep, states)
+            dep.per_state_flush_actions(uow, states_for_prop, False)
+
+class DeleteAll(PostSortRec):
+    def __init__(self, uow, mapper):
+        self.mapper = mapper
+        assert mapper is mapper.base_mapper
+
+    def execute(self, uow):
+        self.mapper._delete_obj(
+            uow.states_for_mapper_hierarchy(self.mapper, True, False),
+            uow
+        )
+
+    def per_state_flush_actions(self, uow):
+        states = list(uow.states_for_mapper_hierarchy(self.mapper, True, False))
+        for rec in self.mapper._per_state_flush_actions(
+                            uow, 
+                            states, 
+                            True):
+            yield rec
+
+        for dep in uow.deps[self.mapper]:
+            states_for_prop = uow.filter_states_for_dep(dep, states)
+            dep.per_state_flush_actions(uow, states_for_prop, True)
+
+class ProcessState(PostSortRec):
+    def __init__(self, uow, dependency_processor, delete, state):
+        self.dependency_processor = dependency_processor
+        self.delete = delete
+        self.state = state
+
+    def execute_aggregate(self, uow, recs):
+        cls_ = self.__class__
+        dependency_processor = self.dependency_processor
+        delete = self.delete
+        our_recs = [r for r in recs 
+                        if r.__class__ is cls_ and 
+                        r.dependency_processor is dependency_processor and
+                        r.delete is delete]
+        recs.difference_update(our_recs)
+        states = [self.state] + [r.state for r in our_recs]
+        if delete:
+            dependency_processor.process_deletes(uow, states)
+        else:
+            dependency_processor.process_saves(uow, states)
+
+    def __repr__(self):
+        return "%s(%s, %s, delete=%s)" % (
+            self.__class__.__name__,
+            self.dependency_processor,
+            mapperutil.state_str(self.state),
+            self.delete
+        )
+
+class SaveUpdateState(PostSortRec):
+    def __init__(self, uow, state, mapper):
+        self.state = state
+        self.mapper = mapper
+
+    def execute_aggregate(self, uow, recs):
+        cls_ = self.__class__
+        mapper = self.mapper
+        our_recs = [r for r in recs 
+                        if r.__class__ is cls_ and 
+                        r.mapper is mapper]
+        recs.difference_update(our_recs)
+        mapper._save_obj(
+                        [self.state] + 
+                        [r.state for r in our_recs], 
+                        uow)
+
+    def __repr__(self):
+        return "%s(%s)" % (
+            self.__class__.__name__,
+            mapperutil.state_str(self.state)
+        )
+
+class DeleteState(PostSortRec):
+    def __init__(self, uow, state, mapper):
+        self.state = state
+        self.mapper = mapper
+
+    def execute_aggregate(self, uow, recs):
+        cls_ = self.__class__
+        mapper = self.mapper
+        our_recs = [r for r in recs 
+                        if r.__class__ is cls_ and 
+                        r.mapper is mapper]
+        recs.difference_update(our_recs)
+        states = [self.state] + [r.state for r in our_recs]
+        mapper._delete_obj(
+                        [s for s in states if uow.states[s][0]], 
+                        uow)
+
+    def __repr__(self):
+        return "%s(%s)" % (
+            self.__class__.__name__,
+            mapperutil.state_str(self.state)
+        )
+

libs/sqlalchemy/orm/util.py

@@ -0,0 +1,691 @@
+# orm/util.py
+# Copyright (C) 2005-2011 the SQLAlchemy authors and contributors <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+import sqlalchemy.exceptions as sa_exc
+from sqlalchemy import sql, util
+from sqlalchemy.sql import expression, util as sql_util, operators
+from sqlalchemy.orm.interfaces import MapperExtension, EXT_CONTINUE,\
+                                PropComparator, MapperProperty,\
+                                AttributeExtension
+from sqlalchemy.orm import attributes, exc
+
+mapperlib = util.importlater("sqlalchemy.orm", "mapperlib")
+
+all_cascades = frozenset(("delete", "delete-orphan", "all", "merge",
+                          "expunge", "save-update", "refresh-expire",
+                          "none"))
+
+_INSTRUMENTOR = ('mapper', 'instrumentor')
+
+class CascadeOptions(object):
+    """Keeps track of the options sent to relationship().cascade"""
+
+    def __init__(self, arg=""):
+        if not arg:
+            values = set()
+        else:
+            values = set(c.strip() for c in arg.split(','))
+        self.delete_orphan = "delete-orphan" in values
+        self.delete = "delete" in values or "all" in values
+        self.save_update = "save-update" in values or "all" in values
+        self.merge = "merge" in values or "all" in values
+        self.expunge = "expunge" in values or "all" in values
+        self.refresh_expire = "refresh-expire" in values or "all" in values
+
+        if self.delete_orphan and not self.delete:
+            util.warn("The 'delete-orphan' cascade option requires "
+                        "'delete'.  This will raise an error in 0.6.")
+
+        for x in values:
+            if x not in all_cascades:
+                raise sa_exc.ArgumentError("Invalid cascade option '%s'" % x)
+
+    def __contains__(self, item):
+        return getattr(self, item.replace("-", "_"), False)
+
+    def __repr__(self):
+        return "CascadeOptions(%s)" % repr(",".join(
+            [x for x in ['delete', 'save_update', 'merge', 'expunge',
+                         'delete_orphan', 'refresh-expire']
+             if getattr(self, x, False) is True]))
+
+
+class Validator(AttributeExtension):
+    """Runs a validation method on an attribute value to be set or appended.
+
+    The Validator class is used by the :func:`~sqlalchemy.orm.validates`
+    decorator, and direct access is usually not needed.
+
+    """
+
+    def __init__(self, key, validator):
+        """Construct a new Validator.
+
+            key - name of the attribute to be validated;
+            will be passed as the second argument to
+            the validation method (the first is the object instance itself).
+
+            validator - an function or instance method which accepts
+            three arguments; an instance (usually just 'self' for a method),
+            the key name of the attribute, and the value.  The function should
+            return the same value given, unless it wishes to modify it.
+
+        """
+        self.key = key
+        self.validator = validator
+
+    def append(self, state, value, initiator):
+        return self.validator(state.obj(), self.key, value)
+
+    def set(self, state, value, oldvalue, initiator):
+        return self.validator(state.obj(), self.key, value)
+
+def polymorphic_union(table_map, typecolname, aliasname='p_union'):
+    """Create a ``UNION`` statement used by a polymorphic mapper.
+
+    See  :ref:`concrete_inheritance` for an example of how
+    this is used.
+    """
+
+    colnames = set()
+    colnamemaps = {}
+    types = {}
+    for key in table_map.keys():
+        table = table_map[key]
+
+        # mysql doesnt like selecting from a select; 
+        # make it an alias of the select
+        if isinstance(table, sql.Select):
+            table = table.alias()
+            table_map[key] = table
+
+        m = {}
+        for c in table.c:
+            colnames.add(c.key)
+            m[c.key] = c
+            types[c.key] = c.type
+        colnamemaps[table] = m
+
+    def col(name, table):
+        try:
+            return colnamemaps[table][name]
+        except KeyError:
+            return sql.cast(sql.null(), types[name]).label(name)
+
+    result = []
+    for type, table in table_map.iteritems():
+        if typecolname is not None:
+            result.append(
+                    sql.select([col(name, table) for name in colnames] +
+                    [sql.literal_column(sql_util._quote_ddl_expr(type)).
+                            label(typecolname)],
+                             from_obj=[table]))
+        else:
+            result.append(sql.select([col(name, table) for name in colnames],
+                                     from_obj=[table]))
+    return sql.union_all(*result).alias(aliasname)
+
+def identity_key(*args, **kwargs):
+    """Get an identity key.
+
+    Valid call signatures:
+
+    * ``identity_key(class, ident)``
+
+      class
+          mapped class (must be a positional argument)
+
+      ident
+          primary key, if the key is composite this is a tuple
+
+
+    * ``identity_key(instance=instance)``
+
+      instance
+          object instance (must be given as a keyword arg)
+
+    * ``identity_key(class, row=row)``
+
+      class
+          mapped class (must be a positional argument)
+
+      row
+          result proxy row (must be given as a keyword arg)
+
+    """
+    if args:
+        if len(args) == 1:
+            class_ = args[0]
+            try:
+                row = kwargs.pop("row")
+            except KeyError:
+                ident = kwargs.pop("ident")
+        elif len(args) == 2:
+            class_, ident = args
+        elif len(args) == 3:
+            class_, ident = args
+        else:
+            raise sa_exc.ArgumentError("expected up to three "
+                "positional arguments, got %s" % len(args))
+        if kwargs:
+            raise sa_exc.ArgumentError("unknown keyword arguments: %s"
+                % ", ".join(kwargs.keys()))
+        mapper = class_mapper(class_)
+        if "ident" in locals():
+            return mapper.identity_key_from_primary_key(ident)
+        return mapper.identity_key_from_row(row)
+    instance = kwargs.pop("instance")
+    if kwargs:
+        raise sa_exc.ArgumentError("unknown keyword arguments: %s"
+            % ", ".join(kwargs.keys()))
+    mapper = object_mapper(instance)
+    return mapper.identity_key_from_instance(instance)
+
+class ExtensionCarrier(dict):
+    """Fronts an ordered collection of MapperExtension objects.
+
+    Bundles multiple MapperExtensions into a unified callable unit,
+    encapsulating ordering, looping and EXT_CONTINUE logic.  The
+    ExtensionCarrier implements the MapperExtension interface, e.g.::
+
+      carrier.after_insert(...args...)
+
+    The dictionary interface provides containment for implemented
+    method names mapped to a callable which executes that method
+    for participating extensions.
+
+    """
+
+    interface = set(method for method in dir(MapperExtension)
+                    if not method.startswith('_'))
+
+    def __init__(self, extensions=None):
+        self._extensions = []
+        for ext in extensions or ():
+            self.append(ext)
+
+    def copy(self):
+        return ExtensionCarrier(self._extensions)
+
+    def push(self, extension):
+        """Insert a MapperExtension at the beginning of the collection."""
+        self._register(extension)
+        self._extensions.insert(0, extension)
+
+    def append(self, extension):
+        """Append a MapperExtension at the end of the collection."""
+        self._register(extension)
+        self._extensions.append(extension)
+
+    def __iter__(self):
+        """Iterate over MapperExtensions in the collection."""
+        return iter(self._extensions)
+
+    def _register(self, extension):
+        """Register callable fronts for overridden interface methods."""
+
+        for method in self.interface.difference(self):
+            impl = getattr(extension, method, None)
+            if impl and impl is not getattr(MapperExtension, method):
+                self[method] = self._create_do(method)
+
+    def _create_do(self, method):
+        """Return a closure that loops over impls of the named method."""
+
+        def _do(*args, **kwargs):
+            for ext in self._extensions:
+                ret = getattr(ext, method)(*args, **kwargs)
+                if ret is not EXT_CONTINUE:
+                    return ret
+            else:
+                return EXT_CONTINUE
+        _do.__name__ = method
+        return _do
+
+    @staticmethod
+    def _pass(*args, **kwargs):
+        return EXT_CONTINUE
+
+    def __getattr__(self, key):
+        """Delegate MapperExtension methods to bundled fronts."""
+
+        if key not in self.interface:
+            raise AttributeError(key)
+        return self.get(key, self._pass)
+
+class ORMAdapter(sql_util.ColumnAdapter):
+    """Extends ColumnAdapter to accept ORM entities.
+
+    The selectable is extracted from the given entity,
+    and the AliasedClass if any is referenced.
+
+    """
+    def __init__(self, entity, equivalents=None, 
+                            chain_to=None, adapt_required=False):
+        self.mapper, selectable, is_aliased_class = _entity_info(entity)
+        if is_aliased_class:
+            self.aliased_class = entity
+        else:
+            self.aliased_class = None
+        sql_util.ColumnAdapter.__init__(self, selectable, 
+                                        equivalents, chain_to,
+                                        adapt_required=adapt_required)
+
+    def replace(self, elem):
+        entity = elem._annotations.get('parentmapper', None)
+        if not entity or entity.isa(self.mapper):
+            return sql_util.ColumnAdapter.replace(self, elem)
+        else:
+            return None
+
+class AliasedClass(object):
+    """Represents an "aliased" form of a mapped class for usage with Query.
+
+    The ORM equivalent of a :func:`sqlalchemy.sql.expression.alias`
+    construct, this object mimics the mapped class using a
+    __getattr__ scheme and maintains a reference to a
+    real :class:`~sqlalchemy.sql.expression.Alias` object.
+
+    Usage is via the :class:`~sqlalchemy.orm.aliased()` synonym::
+
+        # find all pairs of users with the same name
+        user_alias = aliased(User)
+        session.query(User, user_alias).\\
+                        join((user_alias, User.id > user_alias.id)).\\
+                        filter(User.name==user_alias.name)
+
+    """
+    def __init__(self, cls, alias=None, name=None):
+        self.__mapper = _class_to_mapper(cls)
+        self.__target = self.__mapper.class_
+        if alias is None:
+            alias = self.__mapper._with_polymorphic_selectable.alias()
+        self.__adapter = sql_util.ClauseAdapter(alias,
+                                equivalents=self.__mapper._equivalent_columns)
+        self.__alias = alias
+        # used to assign a name to the RowTuple object
+        # returned by Query.
+        self._sa_label_name = name
+        self.__name__ = 'AliasedClass_' + str(self.__target)
+
+    def __getstate__(self):
+        return {
+            'mapper':self.__mapper, 
+            'alias':self.__alias, 
+            'name':self._sa_label_name
+        }
+
+    def __setstate__(self, state):
+        self.__mapper = state['mapper']
+        self.__target = self.__mapper.class_
+        alias = state['alias']
+        self.__adapter = sql_util.ClauseAdapter(alias,
+                                equivalents=self.__mapper._equivalent_columns)
+        self.__alias = alias
+        name = state['name']
+        self._sa_label_name = name
+        self.__name__ = 'AliasedClass_' + str(self.__target)
+
+    def __adapt_element(self, elem):
+        return self.__adapter.traverse(elem).\
+                    _annotate({
+                        'parententity': self, 
+                        'parentmapper':self.__mapper}
+                    )
+
+    def __adapt_prop(self, prop):
+        existing = getattr(self.__target, prop.key)
+        comparator = existing.comparator.adapted(self.__adapt_element)
+
+        queryattr = attributes.QueryableAttribute(prop.key,
+            impl=existing.impl, parententity=self, comparator=comparator)
+        setattr(self, prop.key, queryattr)
+        return queryattr
+
+    def __getattr__(self, key):
+        if self.__mapper.has_property(key):
+            return self.__adapt_prop(
+                        self.__mapper.get_property(
+                            key, _compile_mappers=False
+                        )
+                    )
+
+        for base in self.__target.__mro__:
+            try:
+                attr = object.__getattribute__(base, key)
+            except AttributeError:
+                continue
+            else:
+                break
+        else:
+            raise AttributeError(key)
+
+        if hasattr(attr, 'func_code'):
+            is_method = getattr(self.__target, key, None)
+            if is_method and is_method.im_self is not None:
+                return util.types.MethodType(attr.im_func, self, self)
+            else:
+                return None
+        elif hasattr(attr, '__get__'):
+            return attr.__get__(None, self)
+        else:
+            return attr
+
+    def __repr__(self):
+        return '<AliasedClass at 0x%x; %s>' % (
+            id(self), self.__target.__name__)
+
+def _orm_annotate(element, exclude=None):
+    """Deep copy the given ClauseElement, annotating each element with the
+    "_orm_adapt" flag.
+
+    Elements within the exclude collection will be cloned but not annotated.
+
+    """
+    return sql_util._deep_annotate(element, {'_orm_adapt':True}, exclude)
+
+_orm_deannotate = sql_util._deep_deannotate
+
+class _ORMJoin(expression.Join):
+    """Extend Join to support ORM constructs as input."""
+
+    __visit_name__ = expression.Join.__visit_name__
+
+    def __init__(self, left, right, onclause=None, 
+                            isouter=False, join_to_left=True):
+        adapt_from = None
+
+        if hasattr(left, '_orm_mappers'):
+            left_mapper = left._orm_mappers[1]
+            if join_to_left:
+                adapt_from = left.right
+        else:
+            left_mapper, left, left_is_aliased = _entity_info(left)
+            if join_to_left and (left_is_aliased or not left_mapper):
+                adapt_from = left
+
+        right_mapper, right, right_is_aliased = _entity_info(right)
+        if right_is_aliased:
+            adapt_to = right
+        else:
+            adapt_to = None
+
+        if left_mapper or right_mapper:
+            self._orm_mappers = (left_mapper, right_mapper)
+
+            if isinstance(onclause, basestring):
+                prop = left_mapper.get_property(onclause)
+            elif isinstance(onclause, attributes.QueryableAttribute):
+                if adapt_from is None:
+                    adapt_from = onclause.__clause_element__()
+                prop = onclause.property
+            elif isinstance(onclause, MapperProperty):
+                prop = onclause
+            else:
+                prop = None
+
+            if prop:
+                pj, sj, source, dest, \
+                secondary, target_adapter = prop._create_joins(
+                                source_selectable=adapt_from,
+                                dest_selectable=adapt_to,
+                                source_polymorphic=True,
+                                dest_polymorphic=True,
+                                of_type=right_mapper)
+
+                if sj is not None:
+                    left = sql.join(left, secondary, pj, isouter)
+                    onclause = sj
+                else:
+                    onclause = pj
+                self._target_adapter = target_adapter
+
+        expression.Join.__init__(self, left, right, onclause, isouter)
+
+    def join(self, right, onclause=None, isouter=False, join_to_left=True):
+        return _ORMJoin(self, right, onclause, isouter, join_to_left)
+
+    def outerjoin(self, right, onclause=None, join_to_left=True):
+        return _ORMJoin(self, right, onclause, True, join_to_left)
+
+def join(left, right, onclause=None, isouter=False, join_to_left=True):
+    """Produce an inner join between left and right clauses.
+
+    In addition to the interface provided by
+    :func:`~sqlalchemy.sql.expression.join()`, left and right may be mapped
+    classes or AliasedClass instances. The onclause may be a
+    string name of a relationship(), or a class-bound descriptor
+    representing a relationship.
+
+    join_to_left indicates to attempt aliasing the ON clause,
+    in whatever form it is passed, to the selectable
+    passed as the left side.  If False, the onclause
+    is used as is.
+
+    """
+    return _ORMJoin(left, right, onclause, isouter, join_to_left)
+
+def outerjoin(left, right, onclause=None, join_to_left=True):
+    """Produce a left outer join between left and right clauses.
+
+    In addition to the interface provided by
+    :func:`~sqlalchemy.sql.expression.outerjoin()`, left and right may be
+    mapped classes or AliasedClass instances. The onclause may be a string
+    name of a relationship(), or a class-bound descriptor representing a
+    relationship.
+
+    """
+    return _ORMJoin(left, right, onclause, True, join_to_left)
+
+def with_parent(instance, prop):
+    """Create filtering criterion that relates this query's primary entity
+    to the given related instance, using established :func:`.relationship()`
+    configuration.
+
+    The SQL rendered is the same as that rendered when a lazy loader
+    would fire off from the given parent on that attribute, meaning
+    that the appropriate state is taken from the parent object in 
+    Python without the need to render joins to the parent table
+    in the rendered statement.
+
+    As of 0.6.4, this method accepts parent instances in all 
+    persistence states, including transient, persistent, and detached.
+    Only the requisite primary key/foreign key attributes need to
+    be populated.  Previous versions didn't work with transient
+    instances.
+
+    :param instance:
+      An instance which has some :func:`.relationship`.
+
+    :param property:
+      String property name, or class-bound attribute, which indicates
+      what relationship from the instance should be used to reconcile the 
+      parent/child relationship. 
+
+    """
+    if isinstance(prop, basestring):
+        mapper = object_mapper(instance)
+        prop = mapper.get_property(prop, resolve_synonyms=True)
+    elif isinstance(prop, attributes.QueryableAttribute):
+        prop = prop.property
+
+    return prop.compare(operators.eq, 
+                        instance, 
+                        value_is_parent=True)
+
+
+def _entity_info(entity, compile=True):
+    """Return mapping information given a class, mapper, or AliasedClass.
+
+    Returns 3-tuple of: mapper, mapped selectable, boolean indicating if this
+    is an aliased() construct.
+
+    If the given entity is not a mapper, mapped class, or aliased construct,
+    returns None, the entity, False.  This is typically used to allow
+    unmapped selectables through.
+
+    """
+    if isinstance(entity, AliasedClass):
+        return entity._AliasedClass__mapper, entity._AliasedClass__alias, True
+
+    if isinstance(entity, mapperlib.Mapper):
+        mapper = entity
+
+    elif isinstance(entity, type):
+        class_manager = attributes.manager_of_class(entity)
+
+        if class_manager is None:
+            return None, entity, False
+
+        mapper = class_manager.mapper
+    else:
+        return None, entity, False
+
+    if compile:
+        mapper = mapper.compile()
+    return mapper, mapper._with_polymorphic_selectable, False
+
+def _entity_descriptor(entity, key):
+    """Return a class attribute given an entity and string name.
+
+    May return :class:`.InstrumentedAttribute` or user-defined
+    attribute.
+
+    """
+    if not isinstance(entity, (AliasedClass, type)):
+        entity = entity.class_
+
+    try:
+        return getattr(entity, key)
+    except AttributeError:
+        raise sa_exc.InvalidRequestError(
+                    "Entity '%s' has no property '%s'" % 
+                    (entity, key)
+                )
+
+def _orm_columns(entity):
+    mapper, selectable, is_aliased_class = _entity_info(entity)
+    if isinstance(selectable, expression.Selectable):
+        return [c for c in selectable.c]
+    else:
+        return [selectable]
+
+def _orm_selectable(entity):
+    mapper, selectable, is_aliased_class = _entity_info(entity)
+    return selectable
+
+def _attr_as_key(attr):
+    if hasattr(attr, 'key'):
+        return attr.key
+    else:
+        return expression._column_as_key(attr)
+
+def _is_aliased_class(entity):
+    return isinstance(entity, AliasedClass)
+
+def _state_mapper(state):
+    return state.manager.mapper
+
+def object_mapper(instance):
+    """Given an object, return the primary Mapper associated with the object
+    instance.
+
+    Raises UnmappedInstanceError if no mapping is configured.
+
+    """
+    try:
+        state = attributes.instance_state(instance)
+        return state.manager.mapper
+    except exc.UnmappedClassError:
+        raise exc.UnmappedInstanceError(instance)
+    except exc.NO_STATE:
+        raise exc.UnmappedInstanceError(instance)
+
+def class_mapper(class_, compile=True):
+    """Given a class, return the primary Mapper associated with the key.
+
+    Raises UnmappedClassError if no mapping is configured.
+
+    """
+
+    try:
+        class_manager = attributes.manager_of_class(class_)
+        mapper = class_manager.mapper
+
+    except exc.NO_STATE:
+        raise exc.UnmappedClassError(class_)
+
+    if compile:
+        mapper = mapper.compile()
+    return mapper
+
+def _class_to_mapper(class_or_mapper, compile=True):
+    if _is_aliased_class(class_or_mapper):
+        return class_or_mapper._AliasedClass__mapper
+
+    elif isinstance(class_or_mapper, type):
+        try:
+            class_manager = attributes.manager_of_class(class_or_mapper)
+            mapper = class_manager.mapper
+        except exc.NO_STATE:
+            raise exc.UnmappedClassError(class_or_mapper)
+    elif isinstance(class_or_mapper, mapperlib.Mapper):
+        mapper = class_or_mapper
+    else:
+        raise exc.UnmappedClassError(class_or_mapper)
+
+    if compile:
+        return mapper.compile()
+    else:
+        return mapper
+
+def has_identity(object):
+    state = attributes.instance_state(object)
+    return state.has_identity
+
+def _is_mapped_class(cls):
+    if isinstance(cls, (AliasedClass, mapperlib.Mapper)):
+        return True
+    if isinstance(cls, expression.ClauseElement):
+        return False
+    if isinstance(cls, type):
+        manager = attributes.manager_of_class(cls)
+        return manager and _INSTRUMENTOR in manager.info
+    return False
+
+def instance_str(instance):
+    """Return a string describing an instance."""
+
+    return state_str(attributes.instance_state(instance))
+
+def state_str(state):
+    """Return a string describing an instance via its InstanceState."""
+
+    if state is None:
+        return "None"
+    else:
+        return '<%s at 0x%x>' % (state.class_.__name__, id(state.obj()))
+
+def attribute_str(instance, attribute):
+    return instance_str(instance) + "." + attribute
+
+def state_attribute_str(state, attribute):
+    return state_str(state) + "." + attribute
+
+def identity_equal(a, b):
+    if a is b:
+        return True
+    if a is None or b is None:
+        return False
+    try:
+        state_a = attributes.instance_state(a)
+        state_b = attributes.instance_state(b)
+    except exc.NO_STATE:
+        return False
+    if state_a.key is None or state_b.key is None:
+        return False
+    return state_a.key == state_b.key
+