progress so far

4 files changed, 80 insertions, 44 deletions

diff --git a/lib/sqlalchemy/orm/interfaces.py b/lib/sqlalchemy/orm/interfaces.py
index 631d3f582..6a333cb2c 100644
--- a/lib/sqlalchemy/orm/interfaces.py
+++ b/lib/sqlalchemy/orm/interfaces.py
@@ -438,9 +438,17 @@ class PropComparator(expression.ColumnOperators):
     PropComparator.
     """
 
+    def __init__(self, prop, mapper, adapter=None):
+        self.prop = self.property = prop
+        self.mapper = mapper
+        self.adapter = adapter
+
     def __clause_element__(self):
         raise NotImplementedError("%r" % self)
 
+    def adapted(self, adapter):
+        return self.__class__(self.prop, self.mapper, adapter)
+        
     @staticmethod
     def any_op(a, b, **kwargs):
         return a.any(b, **kwargs)
@@ -449,10 +457,6 @@ class PropComparator(expression.ColumnOperators):
     def has_op(a, b, **kwargs):
         return a.has(b, **kwargs)
 
-    def __init__(self, prop, mapper):
-        self.prop = self.property = prop
-        self.mapper = mapper
-
     @staticmethod
     def of_type_op(a, class_):
         return a.of_type(class_)
diff --git a/lib/sqlalchemy/orm/properties.py b/lib/sqlalchemy/orm/properties.py
index 87e35eb83..81b048af7 100644
--- a/lib/sqlalchemy/orm/properties.py
+++ b/lib/sqlalchemy/orm/properties.py
@@ -85,8 +85,11 @@ class ColumnProperty(StrategizedProperty):
     class ColumnComparator(PropComparator):
         @util.memoized_instancemethod
         def __clause_element__(self):
-            return self.prop.columns[0]._annotate({"parententity": self.mapper})
-
+            if self.adapter:
+                return self.adapter(self.prop.columns[0])
+            else:
+                return self.prop.columns[0]._annotate({"parententity": self.mapper})
+                
         def operate(self, op, *other, **kwargs):
             return op(self.__clause_element__(), *other, **kwargs)
 
@@ -318,18 +321,26 @@ class PropertyLoader(StrategizedProperty):
         self._is_backref = _is_backref
 
     class Comparator(PropComparator):
-        def __init__(self, prop, mapper, of_type=None):
+        def __init__(self, prop, mapper, of_type=None, adapter=None):
             self.prop = self.property = prop
             self.mapper = mapper
+            self.adapter = adapter
             if of_type:
                 self._of_type = _class_to_mapper(of_type)
 
+        def adapted(self, adapter):
+            return PropertyLoader.Comparator(self.prop, self.mapper, getattr(self, '_of_type', None), adapter)
+            
         @property
         def parententity(self):
             return self.prop.parent
 
         def __clause_element__(self):
-            return self.prop.parent._with_polymorphic_selectable
+            elem = self.prop.parent._with_polymorphic_selectable
+            if self.adapter:
+                return self.adapter(elem)
+            else:
+                return elem
 
         def operate(self, op, *other, **kwargs):
             return op(self, *other, **kwargs)
@@ -343,13 +354,15 @@ class PropertyLoader(StrategizedProperty):
         def __eq__(self, other):
             if other is None:
                 if self.prop.direction in [ONETOMANY, MANYTOMANY]:
-                    return ~sql.exists([1], self.prop.primaryjoin)
+                    return ~self._criterion_exists()
                 else:
-                    return self.prop._optimized_compare(None)
+                    return self.prop._optimized_compare(None, adapt_source=self.adapter)
             elif self.prop.uselist:
                 raise sa_exc.InvalidRequestError("Can't compare a collection to an object or collection; use contains() to test for membership.")
             else:
-                return self.prop._optimized_compare(other)
+                import pdb
+                pdb.set_trace()
+                return self.prop._optimized_compare(other, adapt_source=self.adapter)
 
         def _criterion_exists(self, criterion=None, **kwargs):
             if getattr(self, '_of_type', None):
@@ -360,7 +373,12 @@ class PropertyLoader(StrategizedProperty):
             else:
                 to_selectable = None
 
-            pj, sj, source, dest, secondary, target_adapter = self.prop._create_joins(dest_polymorphic=True, dest_selectable=to_selectable)
+            if self.adapter:
+                source_selectable = self.__clause_element__()
+            else:
+                source_selectable = None
+            pj, sj, source, dest, secondary, target_adapter = \
+                self.prop._create_joins(dest_polymorphic=True, dest_selectable=to_selectable, source_selectable=source_selectable)
 
             for k in kwargs:
                 crit = self.prop.mapper.class_manager.get_inst(k) == kwargs[k]
@@ -369,6 +387,7 @@ class PropertyLoader(StrategizedProperty):
                 else:
                     criterion = criterion & crit
 
+            # why are we annotating ????
             if sj:
                 j = _orm_annotate(pj) & sj
             else:
@@ -383,7 +402,10 @@ class PropertyLoader(StrategizedProperty):
             # to anything in the enclosing query.
             if criterion:
                 criterion = criterion._annotate({'_halt_adapt': True})
-            return sql.exists([1], j & criterion, from_obj=dest).correlate(source)
+            
+            crit = j & criterion
+            
+            return sql.exists([1], crit, from_obj=dest).correlate(source)
 
         def any(self, criterion=None, **kwargs):
             if not self.prop.uselist:
@@ -399,7 +421,7 @@ class PropertyLoader(StrategizedProperty):
         def contains(self, other, **kwargs):
             if not self.prop.uselist:
                 raise sa_exc.InvalidRequestError("'contains' not implemented for scalar attributes.  Use ==")
-            clause = self.prop._optimized_compare(other)
+            clause = self.prop._optimized_compare(other, adapt_source=self.adapter)
 
             if self.prop.secondaryjoin:
                 clause.negation_clause = self.__negated_contains_or_equals(other)
@@ -410,12 +432,22 @@ class PropertyLoader(StrategizedProperty):
             if self.prop.direction == MANYTOONE:
                 state = attributes.instance_state(other)
                 strategy = self.prop._get_strategy(strategies.LazyLoader)
+                
+                def state_bindparam(state, col):
+                    o = state.obj() # strong ref
+                    return lambda: self.prop.mapper._get_committed_attr_by_column(o, col)
+                
+                def adapt(col):
+                    if self.adapter:
+                        return self.adapter(col)
+                    else:
+                        return col
+                        
                 if strategy.use_get:
                     return sql.and_(*[
                         sql.or_(
-                        x !=
-                        self.prop.mapper._get_committed_state_attr_by_column(state, y),
-                        x == None)
+                        adapt(x) != state_bindparam(state, y),
+                        adapt(x) == None)
                         for (x, y) in self.prop.local_remote_pairs])
                     
             criterion = sql.and_(*[x==y for (x, y) in zip(self.prop.mapper.primary_key, self.prop.mapper.primary_key_from_instance(other))])
@@ -444,10 +476,11 @@ class PropertyLoader(StrategizedProperty):
         else:
             return op(self.comparator, value)
 
-    def _optimized_compare(self, value, value_is_parent=False):
+    def _optimized_compare(self, value, value_is_parent=False, adapt_source=None):
         if value is not None:
             value = attributes.instance_state(value)
-        return self._get_strategy(strategies.LazyLoader).lazy_clause(value, reverse_direction=not value_is_parent, alias_secondary=True)
+        return self._get_strategy(strategies.LazyLoader).\
+                lazy_clause(value, reverse_direction=not value_is_parent, alias_secondary=True, adapt_source=adapt_source)
 
     def __str__(self):
         return str(self.parent.class_.__name__) + "." + self.key
@@ -605,6 +638,10 @@ class PropertyLoader(StrategizedProperty):
                         "Specify a 'primaryjoin' expression.  If this is a "
                         "many-to-many relation, 'secondaryjoin' is needed as well." % (self))
 
+        self.primaryjoin = self.primaryjoin._annotate({}) #{'_halt_adapt':True})
+#        if self.secondaryjoin:
+#            self.secondaryjoin = self.secondaryjoin._annotate({}) #{'_halt_adapt':True})
+        
     def _col_is_part_of_mappings(self, column):
         if self.secondary is None:
             return self.parent.mapped_table.c.contains_column(column) or \
diff --git a/lib/sqlalchemy/orm/strategies.py b/lib/sqlalchemy/orm/strategies.py
index 1962a7e2d..ba5541944 100644
--- a/lib/sqlalchemy/orm/strategies.py
+++ b/lib/sqlalchemy/orm/strategies.py
@@ -353,9 +353,9 @@ class LazyLoader(AbstractRelationLoader):
         self.is_class_level = True
         self._register_attribute(self.parent.class_, callable_=self.class_level_loader)
 
-    def lazy_clause(self, state, reverse_direction=False, alias_secondary=False):
+    def lazy_clause(self, state, reverse_direction=False, alias_secondary=False, adapt_source=None):
         if state is None:
-            return self._lazy_none_clause(reverse_direction)
+            return self._lazy_none_clause(reverse_direction, adapt_source=adapt_source)
             
         if not reverse_direction:
             (criterion, bind_to_col, rev) = (self.__lazywhere, self.__bind_to_col, self._equated_columns)
@@ -374,9 +374,12 @@ class LazyLoader(AbstractRelationLoader):
         if self.parent_property.secondary and alias_secondary:
             criterion = sql_util.ClauseAdapter(self.parent_property.secondary.alias()).traverse(criterion)
 
-        return visitors.cloned_traverse(criterion, {}, {'bindparam':visit_bindparam})
-    
-    def _lazy_none_clause(self, reverse_direction=False):
+        criterion = visitors.cloned_traverse(criterion, {}, {'bindparam':visit_bindparam})
+        if adapt_source:
+            criterion = adapt_source(criterion)
+        return criterion
+        
+    def _lazy_none_clause(self, reverse_direction=False, adapt_source=None):
         if not reverse_direction:
             (criterion, bind_to_col, rev) = (self.__lazywhere, self.__bind_to_col, self._equated_columns)
         else:
@@ -393,7 +396,10 @@ class LazyLoader(AbstractRelationLoader):
                 binary.right = expression.null()
                 binary.operator = operators.is_
         
-        return visitors.cloned_traverse(criterion, {}, {'binary':visit_binary})
+        criterion = visitors.cloned_traverse(criterion, {}, {'binary':visit_binary})
+        if adapt_source:
+            criterion = adapt_source(criterion)
+        return criterion
         
     def class_level_loader(self, state, options=None, path=None):
         if not mapperutil._state_has_identity(state):
diff --git a/lib/sqlalchemy/orm/util.py b/lib/sqlalchemy/orm/util.py
index 264a4d212..1c8a94669 100644
--- a/lib/sqlalchemy/orm/util.py
+++ b/lib/sqlalchemy/orm/util.py
@@ -263,7 +263,12 @@ class AliasedClass(object):
 
     def __adapt_prop(self, prop):
         existing = getattr(self.__target, prop.key)
-        comparator = AliasedComparator(self, self.__adapter, existing.comparator)
+        
+        adapter = sql_util.ClauseAdapter(self.__alias, equivalents=self.__mapper._equivalent_columns, exclude=getattr(prop, 'remote_side', None))
+        def adapt(elem):
+            return adapter.traverse(elem)._annotate({'parententity': self})
+        comparator = existing.comparator.adapted(adapt)
+
         queryattr = attributes.QueryableAttribute(
             existing.impl, parententity=self, comparator=comparator)
         setattr(self, prop.key, queryattr)
@@ -299,22 +304,6 @@ class AliasedClass(object):
         return '<AliasedClass at 0x%x; %s>' % (
             id(self), self.__target.__name__)
 
-class AliasedComparator(PropComparator):
-    def __init__(self, aliasedclass, adapter, comparator):
-        self.aliasedclass = aliasedclass
-        self.comparator = comparator
-        self.adapter = adapter
-        self.__clause_element = self.adapter.traverse(self.comparator.__clause_element__())._annotate({'parententity': aliasedclass})
-
-    def __clause_element__(self):
-        return self.__clause_element
-
-    def operate(self, op, *other, **kwargs):
-        return self.adapter.traverse(self.comparator.operate(op, *other, **kwargs))
-
-    def reverse_operate(self, op, other, **kwargs):
-        return self.adapter.traverse(self.comparator.reverse_operate(op, *other, **kwargs))
-
 def _orm_annotate(element, exclude=None):
     """Deep copy the given ClauseElement, annotating each element with the "_orm_adapt" flag.
     
@@ -324,8 +313,8 @@ def _orm_annotate(element, exclude=None):
     def clone(elem):
         if exclude and elem in exclude:
             elem = elem._clone()
-        elif '_orm_adapt' not in elem._annotations:
-            elem = elem._annotate({'_orm_adapt':True})
+        elif '_orm_adapt' not in elem._annotations or '_halt_adapt' in elem._annotations:
+            elem = elem._annotate({'_orm_adapt':True, '_halt_adapt':False})
         elem._copy_internals(clone=clone)
         return elem