fixup to printing of uow

diff --git a/lib/sqlalchemy/orm/unitofwork.py b/lib/sqlalchemy/orm/unitofwork.py
index 17c77785a60852cac6b152a3fe66af2b830158de..2dac05b1a6c1973845e41cc83b24d9c43c1d5770 100644 (file)
--- a/lib/sqlalchemy/orm/unitofwork.py
+++ b/lib/sqlalchemy/orm/unitofwork.py
@@ -577,9 +577,11 @@ class UOWExecutor(object):
     def execute_per_element_childtasks(self, trans, task, isdelete):
         for polytask in task.polymorphic_tasks():
             for element in polytask.tosave_elements + polytask.todelete_elements:
-                for child in element.childtasks:
-                    self.execute(trans, child, isdelete)
+                self.execute_element_childtasks(trans, element, isdelete)
     
+    def execute_element_childtasks(self, trans, element, isdelete):
+        for child in element.childtasks:
+            self.execute(trans, child, isdelete)
     
 class UOWTask(object):
     """represents the full list of objects that are to be saved/deleted by a specific Mapper."""

diff --git a/lib/sqlalchemy/orm/uowdumper.py b/lib/sqlalchemy/orm/uowdumper.py
index f49c35d7f059acdb0c260f3ee955596298aae901..e08965ce1c77b29b655861aaf1e52482ece59f95 100644 (file)
--- a/lib/sqlalchemy/orm/uowdumper.py
+++ b/lib/sqlalchemy/orm/uowdumper.py
@@ -9,45 +9,55 @@ class UOWDumper(unitofwork.UOWExecutor):
         self.task = task
         self.buf = buf
         self.starttask = task
-        #self.execute(None, task)
-        self._dump(task)
-
-    # execute stuff is UNDER CONSTRUCTION
+        self.headers = {}
+        self.execute(None, task)
     
     def execute(self, trans, task, isdelete=None):
         oldstarttask = self.starttask
+        oldheaders = self.headers
         self.starttask = task
+        self.headers = {}
         try:
             i = self._indent()
             if len(i):
-                i = i[0:-1] + "-"
+                i += "-"
+                #i = i[0:-1] + "-"
             if task.circular is not None:
                 self.buf.write(self._indent() + "\n")
                 self.buf.write(i + " " + self._repr_task(task))
-                self.buf.write("->circular->" + self._repr_task(task.circular))
+                self.buf.write(" (contains cyclical sub-tasks)")
             else:
                 self.buf.write(self._indent() + "\n")
                 self.buf.write(i + " " + self._repr_task(task))
-            self.buf.write("\n")
+            self.buf.write(" (" + (isdelete and "delete " or "save/update ") + "phase) \n")
+            self.indent += 1
             super(UOWDumper, self).execute(trans, task, isdelete)
         finally:
+            self.indent -= 1
+            if self.starttask.is_empty():   
+                self.buf.write(self._indent() + "   |- (empty task)\n")
+            else:
+                self.buf.write(self._indent() + "   |----\n")
+
+            self.buf.write(self._indent() + "\n")           
             self.starttask = oldstarttask
+            self.headers = oldheaders
             
     def save_objects(self, trans, task):
         for rec in task.tosave_elements:
             if rec.listonly:
                 continue
-            if self.verbose:
-                header(self.buf, self._indent() + "  |- Save elements"+ self._inheritance_tag(task) + "\n")
-            self.buf.write(self._indent() + "  |- " + self._repr_task_element(rec)  + "\n")
-
+            self.header("Save elements"+ self._inheritance_tag(task))
+            self.buf.write(self._indent() + "- " + self._repr_task_element(rec)  + "\n")
+            self.closeheader()
+            
     def delete_objects(self, trans, task):
         for rec in task.todelete_elements:
             if rec.listonly:
                 continue
-            if self.verbose:
-                header(self.buf, self._indent() + "  |- Delete elements"+ self._inheritance_tag(task) + "\n")
-            self.buf.write(self._indent() + "  |- " + self._repr_task_element(rec)  + "\n")
+            self.header("Delete elements"+ self._inheritance_tag(task))
+            self.buf.write(self._indent() + "- " + self._repr_task_element(rec)  + "\n")
+            self.closeheader()
 
     def _inheritance_tag(self, task):
         if not self.verbose:
@@ -57,9 +67,23 @@ class UOWDumper(unitofwork.UOWExecutor):
         else:
             return ""
 
+    def header(self, text):
+        """write a given header just once"""
+        if not self.verbose:
+            return
+        try:
+            self.headers[text]
+        except KeyError:
+            self.buf.write(self._indent() +  "- " + text + "\n")
+            self.headers[text] = True
+
+    def closeheader(self):
+        if not self.verbose:
+            return
+        self.buf.write(self._indent() + "- ------\n")
+
     def execute_dependency(self, transaction, dep, isdelete):
-        #self.buf.write()
-        pass
+        self._dump_processor(dep, isdelete)
 
     def execute_save_steps(self, trans, task):
         super(UOWDumper, self).execute_save_steps(trans, task)
@@ -71,13 +95,22 @@ class UOWDumper(unitofwork.UOWExecutor):
         super(UOWDumper, self).execute_dependencies(trans, task, isdelete)
 
     def execute_childtasks(self, trans, task, isdelete=None):
+        self.header("Child tasks" + self._inheritance_tag(task))
         super(UOWDumper, self).execute_childtasks(trans, task, isdelete)
-
+        self.closeheader()
+        
     def execute_cyclical_dependencies(self, trans, task, isdelete):
+        self.header("Cyclical %s dependencies" % (isdelete and "delete" or "save"))
         super(UOWDumper, self).execute_cyclical_dependencies(trans, task, isdelete)
-
+        self.closeheader()
+            
     def execute_per_element_childtasks(self, trans, task, isdelete):
         super(UOWDumper, self).execute_per_element_childtasks(trans, task, isdelete)
+
+    def execute_element_childtasks(self, trans, element, isdelete):
+        self.header("%s subelements of UOWTaskElement(%s)" % ((isdelete and "Delete" or "Save"), id(element)))
+        super(UOWDumper, self).execute_element_childtasks(trans, element, isdelete)
+        self.closeheader()
         
     def _dump_processor(self, proc, deletes):
         if deletes:
@@ -86,14 +119,14 @@ class UOWDumper(unitofwork.UOWExecutor):
             val = proc.targettask.polymorphic_tosave_elements
 
         if self.verbose:
-            self.buf.write(self._indent() + "  |- %s attribute on %s (UOWDependencyProcessor(%d) processing %s)\n" % (
+            self.buf.write(self._indent() + "   |- %s attribute on %s (UOWDependencyProcessor(%d) processing %s)\n" % (
                 repr(proc.processor.key), 
                     ("%s's to be %s" % (self._repr_task_class(proc.targettask), deletes and "deleted" or "saved")),
                 id(proc), 
                 self._repr_task(proc.targettask))
             )
         elif False:
-            self.buf.write(self._indent() + "  |- %s attribute on %s\n" % (
+            self.buf.write(self._indent() + "   |- %s attribute on %s\n" % (
                 repr(proc.processor.key), 
                     ("%s's to be %s" % (self._repr_task_class(proc.targettask), deletes and "deleted" or "saved")),
                 )
@@ -101,9 +134,9 @@ class UOWDumper(unitofwork.UOWExecutor):
             
         if len(val) == 0:
             if self.verbose:
-                self.buf.write(self._indent() + "  |       |-" + "(no objects)\n")
+                self.buf.write(self._indent() + "   |- " + "(no objects)\n")
         for v in val:
-            self.buf.write(self._indent() + "  |       |-" + self._repr_task_element(v, proc.processor.key, process=True) + "\n")
+            self.buf.write(self._indent() + "   |- " + self._repr_task_element(v, proc.processor.key, process=True) + "\n")
 
     def _repr_task_element(self, te, attribute=None, process=False):
         if te.obj is None:
@@ -128,7 +161,10 @@ class UOWDumper(unitofwork.UOWExecutor):
                 name = repr(task.mapper)
         else:
             name = '(none)'
-        return ("UOWTask(%d, %s)" % (id(task), name))
+        if task.circular_parent:
+            return ("UOWTask(%d->%d, %s)" % (id(task.circular_parent), id(task), name))
+        else:
+            return ("UOWTask(%d, %s)" % (id(task), name))
         
     def _repr_task_class(self, task):
         if task.mapper is not None and task.mapper.__class__.__name__ == 'Mapper':
@@ -140,121 +176,5 @@ class UOWDumper(unitofwork.UOWExecutor):
         return "%s(%d)" % (obj.__class__.__name__, id(obj))
 
     def _indent(self):
-        return "  | " * self.indent
-
-    def _dump(self, starttask, indent=None, circularparent=None):
-        try:
-            oldindent = self.indent
-            if indent is not None:
-                self.indent = indent
-            self._dump_impl(starttask, circularparent=circularparent)
-        finally:
-            self.indent = oldindent
-            
-    def _dump_impl(self, starttask, circularparent=None):
-
-        headers = {}
-        def header(buf, text):
-            """writes a given header just once"""
-            try:
-                headers[text]
-            except KeyError:
-                self.buf.write(self._indent() + "  |\n")
-                self.buf.write(text)
-                headers[text] = True
-
-        def _inheritance_tag(task):
-            if not self.verbose:
-                return ""
-            elif task is not starttask:
-                return (" (inheriting task %s)" % self._repr_task(task))
-            else:
-                return ""
-
-        def _dump_saveelements(task):
-            for ptask in task.polymorphic_tasks():
-                for rec in ptask.tosave_elements:
-                    if rec.listonly:
-                        continue
-                    if self.verbose:
-                        header(self.buf, self._indent() + "  |- Save elements"+ _inheritance_tag(task) + "\n")
-                    self.buf.write(self._indent() + "  |- " + self._repr_task_element(rec)  + "\n")
-
-        def _dump_deleteelements(task):
-            for ptask in task.polymorphic_tasks():
-                for rec in ptask.todelete_elements:
-                    if rec.listonly:
-                        continue
-                    if self.verbose:
-                        header(self.buf, self._indent() + "  |- Delete elements"+ _inheritance_tag(ptask) + "\n")
-                    self.buf.write(self._indent() + "  |- " + self._repr_task_element(rec) + "\n")
-
-        def _dump_dependencies(task):
-            alltasks = list(task.polymorphic_tasks())
-            for task in alltasks:
-                for dep in task.dependencies:
-                    if self.verbose:
-                        header(self.buf, self._indent() + "  |- Save dependencies" + _inheritance_tag(task) + "\n")
-                    self._dump_processor(dep, False)
-            alltasks.reverse()
-            for task in alltasks:
-                for dep in task.dependencies:
-                    if self.verbose:
-                        header(self.buf, self._indent() + "  |- Delete dependencies" + _inheritance_tag(task) + "\n")
-                    self._dump_processor(dep, True)
-    
-        def _dump_childtasks(task):
-            for ptask in task.polymorphic_tasks():
-                for child in ptask.childtasks:
-                    if self.verbose:
-                        header(self.buf, self._indent() + "  |- Child tasks" + _inheritance_tag(task) + "\n")
-                    self._dump(child, indent = self.indent + 1)
-        
-        if starttask.circular is not None:
-            self._dump(starttask.circular, indent=self.indent, circularparent=starttask)
-            return
-
-
-        i = self._indent()
-        if len(i):
-            i = i[0:-1] + "-"
-        if circularparent is not None:
-            self.buf.write(self._indent() + "\n")
-            self.buf.write(i + " " + self._repr_task(circularparent))
-            self.buf.write("->circular->" + self._repr_task(starttask))
-        else:
-            self.buf.write(self._indent() + "\n")
-            self.buf.write(i + " " + self._repr_task(starttask))
-        
-        self.buf.write("\n")
-        _dump_saveelements(starttask)
-        for dep in starttask.cyclical_dependencies:
-            if self.verbose:
-                header(self.buf, self._indent() + "  |- Cyclical Save dependencies\n")
-            self._dump_processor(dep, False)
-        for element in starttask.tosave_elements:
-            for task in element.childtasks:
-                if self.verbose:
-                    header(self.buf, self._indent() + "  |- Save subelements of UOWTaskElement(%s)\n" % id(element))
-                self._dump(task, indent = self.indent + 1)
-        _dump_dependencies(starttask)
-        for dep in starttask.cyclical_dependencies:
-            if self.verbose:
-                header(self.buf, self._indent() + "  |- Cyclical Delete dependencies\n")
-            self._dump_processor(dep, True)
-        _dump_childtasks(starttask)
-        for element in starttask.todelete_elements:
-            for task in element.childtasks:
-                if self.verbose:
-                    header(self.buf, self._indent() + "  |- Delete subelements of UOWTaskElement(%s)\n" % id(element))
-                self._dump(task, indent = self.indent + 1)
-        _dump_deleteelements(starttask)
-
-        if starttask.is_empty():   
-            self.buf.write(self._indent() + "  |- (empty task)\n")
-        else:
-            self.buf.write(self._indent() + "  |----\n")
-        
-        self.buf.write(self._indent() + "\n")           
-
+        return "   |" * self.indent