From 50719c0bb0bb2db51c0fe2024cb03d4b41ae650b Mon Sep 17 00:00:00 2001 From: Mike Bayer Date: Sun, 2 Nov 2008 22:11:40 +0000 Subject: revert r5220 inadvertently committed to trunk --- lib/sqlalchemy/orm/interfaces.py | 12 +++---- lib/sqlalchemy/orm/properties.py | 67 +++++++++------------------------------- lib/sqlalchemy/orm/strategies.py | 18 ++++------- lib/sqlalchemy/orm/util.py | 27 +++++++++++----- 4 files changed, 44 insertions(+), 80 deletions(-) (limited to 'lib') diff --git a/lib/sqlalchemy/orm/interfaces.py b/lib/sqlalchemy/orm/interfaces.py index 6a333cb2c..631d3f582 100644 --- a/lib/sqlalchemy/orm/interfaces.py +++ b/lib/sqlalchemy/orm/interfaces.py @@ -438,17 +438,9 @@ 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) @@ -457,6 +449,10 @@ 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 81b048af7..87e35eb83 100644 --- a/lib/sqlalchemy/orm/properties.py +++ b/lib/sqlalchemy/orm/properties.py @@ -85,11 +85,8 @@ class ColumnProperty(StrategizedProperty): class ColumnComparator(PropComparator): @util.memoized_instancemethod def __clause_element__(self): - if self.adapter: - return self.adapter(self.prop.columns[0]) - else: - return self.prop.columns[0]._annotate({"parententity": self.mapper}) - + return self.prop.columns[0]._annotate({"parententity": self.mapper}) + def operate(self, op, *other, **kwargs): return op(self.__clause_element__(), *other, **kwargs) @@ -321,26 +318,18 @@ class PropertyLoader(StrategizedProperty): self._is_backref = _is_backref class Comparator(PropComparator): - def __init__(self, prop, mapper, of_type=None, adapter=None): + def __init__(self, prop, mapper, of_type=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): - elem = self.prop.parent._with_polymorphic_selectable - if self.adapter: - return self.adapter(elem) - else: - return elem + return self.prop.parent._with_polymorphic_selectable def operate(self, op, *other, **kwargs): return op(self, *other, **kwargs) @@ -354,15 +343,13 @@ class PropertyLoader(StrategizedProperty): def __eq__(self, other): if other is None: if self.prop.direction in [ONETOMANY, MANYTOMANY]: - return ~self._criterion_exists() + return ~sql.exists([1], self.prop.primaryjoin) else: - return self.prop._optimized_compare(None, adapt_source=self.adapter) + return self.prop._optimized_compare(None) 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: - import pdb - pdb.set_trace() - return self.prop._optimized_compare(other, adapt_source=self.adapter) + return self.prop._optimized_compare(other) def _criterion_exists(self, criterion=None, **kwargs): if getattr(self, '_of_type', None): @@ -373,12 +360,7 @@ class PropertyLoader(StrategizedProperty): else: to_selectable = None - 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) + pj, sj, source, dest, secondary, target_adapter = self.prop._create_joins(dest_polymorphic=True, dest_selectable=to_selectable) for k in kwargs: crit = self.prop.mapper.class_manager.get_inst(k) == kwargs[k] @@ -387,7 +369,6 @@ class PropertyLoader(StrategizedProperty): else: criterion = criterion & crit - # why are we annotating ???? if sj: j = _orm_annotate(pj) & sj else: @@ -402,10 +383,7 @@ class PropertyLoader(StrategizedProperty): # to anything in the enclosing query. if criterion: criterion = criterion._annotate({'_halt_adapt': True}) - - crit = j & criterion - - return sql.exists([1], crit, from_obj=dest).correlate(source) + return sql.exists([1], j & criterion, from_obj=dest).correlate(source) def any(self, criterion=None, **kwargs): if not self.prop.uselist: @@ -421,7 +399,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, adapt_source=self.adapter) + clause = self.prop._optimized_compare(other) if self.prop.secondaryjoin: clause.negation_clause = self.__negated_contains_or_equals(other) @@ -432,22 +410,12 @@ 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_( - adapt(x) != state_bindparam(state, y), - adapt(x) == None) + x != + self.prop.mapper._get_committed_state_attr_by_column(state, y), + 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))]) @@ -476,11 +444,10 @@ class PropertyLoader(StrategizedProperty): else: return op(self.comparator, value) - def _optimized_compare(self, value, value_is_parent=False, adapt_source=None): + def _optimized_compare(self, value, value_is_parent=False): 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, adapt_source=adapt_source) + return self._get_strategy(strategies.LazyLoader).lazy_clause(value, reverse_direction=not value_is_parent, alias_secondary=True) def __str__(self): return str(self.parent.class_.__name__) + "." + self.key @@ -638,10 +605,6 @@ 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 ba5541944..1962a7e2d 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, adapt_source=None): + def lazy_clause(self, state, reverse_direction=False, alias_secondary=False): if state is None: - return self._lazy_none_clause(reverse_direction, adapt_source=adapt_source) + return self._lazy_none_clause(reverse_direction) if not reverse_direction: (criterion, bind_to_col, rev) = (self.__lazywhere, self.__bind_to_col, self._equated_columns) @@ -374,12 +374,9 @@ class LazyLoader(AbstractRelationLoader): if self.parent_property.secondary and alias_secondary: criterion = sql_util.ClauseAdapter(self.parent_property.secondary.alias()).traverse(criterion) - 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): + return visitors.cloned_traverse(criterion, {}, {'bindparam':visit_bindparam}) + + def _lazy_none_clause(self, reverse_direction=False): if not reverse_direction: (criterion, bind_to_col, rev) = (self.__lazywhere, self.__bind_to_col, self._equated_columns) else: @@ -396,10 +393,7 @@ class LazyLoader(AbstractRelationLoader): binary.right = expression.null() binary.operator = operators.is_ - criterion = visitors.cloned_traverse(criterion, {}, {'binary':visit_binary}) - if adapt_source: - criterion = adapt_source(criterion) - return criterion + return visitors.cloned_traverse(criterion, {}, {'binary':visit_binary}) 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 1c8a94669..264a4d212 100644 --- a/lib/sqlalchemy/orm/util.py +++ b/lib/sqlalchemy/orm/util.py @@ -263,12 +263,7 @@ class AliasedClass(object): def __adapt_prop(self, prop): existing = getattr(self.__target, prop.key) - - 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) - + comparator = AliasedComparator(self, self.__adapter, existing.comparator) queryattr = attributes.QueryableAttribute( existing.impl, parententity=self, comparator=comparator) setattr(self, prop.key, queryattr) @@ -304,6 +299,22 @@ class AliasedClass(object): return '' % ( 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. @@ -313,8 +324,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 or '_halt_adapt' in elem._annotations: - elem = elem._annotate({'_orm_adapt':True, '_halt_adapt':False}) + elif '_orm_adapt' not in elem._annotations: + elem = elem._annotate({'_orm_adapt':True}) elem._copy_internals(clone=clone) return elem -- cgit v1.2.1