From cd74af72b9765c09fc8614c4666777f76473cc13 Mon Sep 17 00:00:00 2001 From: Mike Bayer Date: Mon, 14 Nov 2005 01:10:25 +0000 Subject: [PATCH] --- lib/sqlalchemy/attributes.py | 105 ++++++++++++++--------------------- lib/sqlalchemy/mapper.py | 25 +++------ test/objectstore.py | 4 +- 3 files changed, 52 insertions(+), 82 deletions(-) diff --git a/lib/sqlalchemy/attributes.py b/lib/sqlalchemy/attributes.py index fe336745ca..78855a8bf1 100644 --- a/lib/sqlalchemy/attributes.py +++ b/lib/sqlalchemy/attributes.py @@ -27,24 +27,16 @@ class SmartProperty(object): self.manager = manager def attribute_registry(self): return self.manager - def property(self, key, uselist, **kwargs): - print "NEW SMART PROP", key, repr(kwargs) + def property(self, key, uselist): def set_prop(obj, value): - if uselist: - self.attribute_registry().set_list_attribute(obj, key, value, **kwargs) - else: - self.attribute_registry().set_attribute(obj, key, value, **kwargs) + self.attribute_registry().set_attribute(obj, key, value) def del_prop(obj): - if uselist: - # TODO: this probably doesnt work right, deleting the list off an item - self.attribute_registry().delete_list_attribute(obj, key, **kwargs) - else: - self.attribute_registry().delete_attribute(obj, key, **kwargs) + self.attribute_registry().delete_attribute(obj, key) def get_prop(obj): if uselist: - return self.attribute_registry().get_list_attribute(obj, key, **kwargs) + return self.attribute_registry().get_list_attribute(obj, key) else: - return self.attribute_registry().get_attribute(obj, key, **kwargs) + return self.attribute_registry().get_attribute(obj, key) return property(get_prop, set_prop, del_prop) @@ -152,30 +144,22 @@ class CallableProp(object): def gethistory(self, passive=False, *args, **kwargs): if not self.uselist: - m = self.manager - self.getattr() - return m.attribute_history(self.obj)[self.key] + if self.obj.__dict__.get(self.key, None) is None: + if passive: + return None + value = self.callable_() + self.obj.__dict__[self.key] = value + + p = PropHistory(self.obj, self.key, **self.kwargs) else: if not self.obj.__dict__.has_key(self.key) or len(self.obj.__dict__[self.key]) == 0: if passive: - print "HI YES" return None - print "doing CALLABLE for key", self.key value = self.callable_() else: value = None - print "WHATEVER THING", self.key p = self.manager.create_list(self.obj, self.key, value, **self.kwargs) - self.manager.attribute_history(self.obj)[self.key] = p - self.manager = None - return p - def getattr(self): - if self.obj.__dict__.get(self.key, None) is None: - value = self.callable_() - self.obj.__dict__[self.key] = value - - p = PropHistory(self.obj, self.key, **self.kwargs) self.manager.attribute_history(self.obj)[self.key] = p self.manager = None return p @@ -194,7 +178,7 @@ class AttributeManager(object): def value_changed(self, obj, key, value): pass def create_prop(self, key, uselist, **kwargs): - return SmartProperty(self).property(key, uselist, **kwargs) + return SmartProperty(self).property(key, uselist) def create_list(self, obj, key, list_, **kwargs): return ListElement(obj, key, list_) @@ -209,15 +193,12 @@ class AttributeManager(object): raise AttributeError(key) def get_list_attribute(self, obj, key, **kwargs): - return self.get_list_history(obj, key, **kwargs) + return self.get_history(obj, key, **kwargs) def set_attribute(self, obj, key, value, **kwargs): self.get_history(obj, key, **kwargs).setattr(value) self.value_changed(obj, key, value) - def set_list_attribute(self, obj, key, value, **kwargs): - self.get_list_history(obj, key, **kwargs).setattr(value) - def delete_attribute(self, obj, key, **kwargs): self.get_history(obj, key, **kwargs).delattr() self.value_changed(obj, key, None) @@ -228,9 +209,6 @@ class AttributeManager(object): def create_callable(self, obj, key, func, uselist, **kwargs): return CallableProp(self, func, obj, key, uselist, **kwargs) - def delete_list_attribute(self, obj, key, **kwargs): - pass - def rollback(self, *obj): for o in obj: try: @@ -252,43 +230,46 @@ class AttributeManager(object): def remove(self, obj): pass - def get_history(self, obj, key, create_prop = None, **kwargs): + def get_history(self, obj, key, create_prop = None, passive=False, **kwargs): try: - return self.attribute_history(obj)[key].gethistory(**kwargs) + return self.attribute_history(obj)[key].gethistory(passive=passive, **kwargs) except KeyError, e: + return self.class_managed(obj.__class__)[key](obj, **kwargs).gethistory(passive=passive, **kwargs) + + def attribute_history(self, obj): + try: + attr = obj.__dict__['_managed_attributes'] + except KeyError: + attr = {} + obj.__dict__['_managed_attributes'] = attr + return attr + + def class_managed(self, class_): + try: + attr = getattr(class_, '_class_managed_attributes') + except AttributeError: + attr = {} + class_._class_managed_attributes = attr + return attr + + def register_attribute(self, class_, key, uselist, create_prop = None, **kwargs): + # create a function, that will create this object attribute when its first called + def createprop(obj, **kwargs): if create_prop is not None: - p = self.create_callable(obj, key, create_prop(obj), uselist=False, **kwargs) + # create the object attribute as a callable + p = self.create_callable(obj, key, create_prop(obj), uselist=uselist, **kwargs) self.attribute_history(obj)[key] = p - return p.gethistory(**kwargs) - else: + return p + elif not uselist: p = PropHistory(obj, key, **kwargs) self.attribute_history(obj)[key] = p return p - - def get_list_history(self, obj, key, passive = False, create_prop = None, **kwargs): - try: - return self.attribute_history(obj)[key].gethistory(passive) - except KeyError, e: - print "GETLISTHISTORY", key, repr(passive), repr(create_prop) - # TODO: when an callable is re-set on an existing list element - if create_prop is not None: - p = self.create_callable(obj, key, create_prop(obj), uselist=True, **kwargs) - self.attribute_history(obj)[key] = p - return p.gethistory(passive) else: list_ = obj.__dict__.get(key, None) p = self.create_list(obj, key, list_, **kwargs) self.attribute_history(obj)[key] = p return p - - def attribute_history(self, obj): - try: - attr = obj.__dict__['_managed_attributes'] - except KeyError: - attr = {} - obj.__dict__['_managed_attributes'] = attr - return attr - def register_attribute(self, class_, key, uselist, **kwargs): - setattr(class_, key, self.create_prop(key, uselist, **kwargs)) + self.class_managed(class_)[key] = createprop + setattr(class_, key, self.create_prop(key, uselist)) diff --git a/lib/sqlalchemy/mapper.py b/lib/sqlalchemy/mapper.py index ab98cd6bf4..e5b384ba5c 100644 --- a/lib/sqlalchemy/mapper.py +++ b/lib/sqlalchemy/mapper.py @@ -475,11 +475,7 @@ class Mapper(object): for col in self.primary_keys[table]: # print "col: " + table.name + "." + col.key + " val: " + repr(self._getattrbycolumn(obj, col)) if self._getattrbycolumn(obj, col) is None: - try: - self._setattrbycolumn(obj, col, primary_keys[i]) - except IndexError: - print "LALALA col: " + table.name + "." + col.key + " val: " + repr(self._getattrbycolumn(obj, col)) - raise + self._setattrbycolumn(obj, col, primary_keys[i]) i+=1 self.extension.after_insert(self, obj) @@ -723,7 +719,6 @@ class PropertyLoader(MapperProperty): #objectstore.uow().register_attribute(parent.class_, key, uselist = self.uselist, deleteremoved = self.private) def _set_class_attribute(self, class_, key): - print "SET NORMAL CA", key objectstore.uow().register_attribute(class_, key, uselist = self.uselist, deleteremoved = self.private) def _get_direction(self): @@ -823,9 +818,7 @@ class PropertyLoader(MapperProperty): return if self.uselist: - print repr(obj), "deleted, getting listm, right now its", repr(obj.__dict__.get(self.key, None)) - childlist = uow.attributes.get_list_history(obj, self.key, passive = False) - print "and its", repr(childlist) + childlist = uow.attributes.get_history(obj, self.key, passive = False) else: childlist = uow.attributes.get_history(obj, self.key) for child in childlist.deleted_items() + childlist.unchanged_items(): @@ -852,10 +845,7 @@ class PropertyLoader(MapperProperty): raise " no foreign key ?" def get_object_dependencies(self, obj, uowcommit, passive = True): - if self.uselist: - return uowcommit.uow.attributes.get_list_history(obj, self.key, passive = passive) - else: - return uowcommit.uow.attributes.get_history(obj, self.key) + return uowcommit.uow.attributes.get_history(obj, self.key, passive = passive) def whose_dependent_on_who(self, obj1, obj2): if obj1 is obj2: @@ -981,7 +971,6 @@ class LazyLoader(PropertyLoader): (self.lazywhere, self.lazybinds) = create_lazy_clause(self.parent.table, self.primaryjoin, self.secondaryjoin, self.foreignkey) def _set_class_attribute(self, class_, key): - print "SET DYNAMIC CA,", key objectstore.uow().register_attribute(class_, key, uselist = self.uselist, deleteremoved = self.private, create_prop=lambda i: self.setup_loader(i)) def setup_loader(self, instance): @@ -1080,10 +1069,10 @@ class EagerLoader(PropertyLoader): towrap = self.parent.table if self.secondaryjoin is not None: - print self.secondary.name - print str(self.secondaryjoin) - print self.target.name - print str(self.primaryjoin) + #print self.secondary.name + #print str(self.secondaryjoin) + #print self.target.name + #print str(self.primaryjoin) statement._outerjoin = sql.outerjoin(towrap, self.secondary, self.primaryjoin).outerjoin(self.target, self.secondaryjoin) statement.order_by(self.secondary.rowid_column) else: diff --git a/test/objectstore.py b/test/objectstore.py index a832b2f3ef..9d2ff68c2d 100644 --- a/test/objectstore.py +++ b/test/objectstore.py @@ -659,8 +659,8 @@ class SaveTest(AssertMixin): objectstore.commit() print repr(u.__dict__.get('addresses', None)) # objectstore.clear() -# objectstore.delete(u) - # objectstore.commit() + objectstore.delete(u) + objectstore.commit() if __name__ == "__main__": -- 2.47.2