(no commit message)

diff --git a/lib/sqlalchemy/attributes.py b/lib/sqlalchemy/attributes.py
index fe336745caecef5c476c0b13e429f1711ca02ce3..78855a8bf13576d46a221905c318cac0e9eb4e98 100644 (file)
--- 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 ab98cd6bf4f3e566015d8ce964b9bd20dc4d0414..e5b384ba5c4ebcd3f26c16f543fabded468a85cb 100644 (file)
--- 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 a832b2f3ef0618ed6ef39080ab4f7231d2089f20..9d2ff68c2dbad48b9c3b01d4c03dde02f423c0b5 100644 (file)
--- 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__":