- for hackers, refactored the "visitor" system of ClauseElement and

SchemaItem so that the traversal of items is controlled by the
ClauseVisitor itself, using the method visitor.traverse(item).
accept_visitor() methods can still be called directly but will
not do any traversal of child items.  ClauseElement/SchemaItem now
have a configurable get_children() method to return the collection
of child elements for each parent object. This allows the full
traversal of items to be clear and unambiguous (as well as loggable),
with an easy method of limiting a traversal (just pass flags which
are picked up by appropriate get_children() methods). [ticket:501]
- accept_schema_visitor() methods removed, replaced with
get_children(schema_visitor=True)
- various docstring/changelog cleanup/reformatting

5 files changed, 23 insertions, 24 deletions

diff --git a/lib/sqlalchemy/orm/mapper.py b/lib/sqlalchemy/orm/mapper.py
index d28445be6..74dd58a3f 100644
--- a/lib/sqlalchemy/orm/mapper.py
+++ b/lib/sqlalchemy/orm/mapper.py
@@ -767,7 +767,7 @@ class Mapper(object):
         vis = mapperutil.BinaryVisitor(visit_binary)
         for mapper in self.base_mapper().polymorphic_iterator():
             if mapper.inherit_condition is not None:
-                mapper.inherit_condition.accept_visitor(vis)
+                vis.traverse(mapper.inherit_condition)
         return result
 
     def add_properties(self, dict_of_properties):
diff --git a/lib/sqlalchemy/orm/properties.py b/lib/sqlalchemy/orm/properties.py
index 2d10b2f9d..c9a2dbe59 100644
--- a/lib/sqlalchemy/orm/properties.py
+++ b/lib/sqlalchemy/orm/properties.py
@@ -233,9 +233,9 @@ class PropertyLoader(StrategizedProperty):
         # error message in case its the "old" way.
         if self.loads_polymorphic:
             vis = sql_util.ColumnsInClause(self.mapper.select_table)
-            self.primaryjoin.accept_visitor(vis)
+            vis.traverse(self.primaryjoin)
             if self.secondaryjoin:
-                self.secondaryjoin.accept_visitor(vis)
+                vis.traverse(self.secondaryjoin)
             if vis.result:
                 raise exceptions.ArgumentError("In relationship '%s', primary and secondary join conditions must not include columns from the polymorphic 'select_table' argument as of SA release 0.3.4.  Construct join conditions using the base tables of the related mappers." % (str(self)))
 
@@ -251,9 +251,9 @@ class PropertyLoader(StrategizedProperty):
                     self._opposite_side.add(binary.right)
                 if binary.right in self.foreign_keys:
                     self._opposite_side.add(binary.left)
-            self.primaryjoin.accept_visitor(mapperutil.BinaryVisitor(visit_binary))
+            mapperutil.BinaryVisitor(visit_binary).traverse(self.primaryjoin)
             if self.secondaryjoin is not None:
-                self.secondaryjoin.accept_visitor(mapperutil.BinaryVisitor(visit_binary))
+                mapperutil.BinaryVisitor(visit_binary).traverse(self.secondaryjoin)
         else:
             self.foreign_keys = util.Set()
             self._opposite_side = util.Set()
@@ -268,12 +268,12 @@ class PropertyLoader(StrategizedProperty):
                     if f.references(binary.left.table):
                         self.foreign_keys.add(binary.right)
                         self._opposite_side.add(binary.left)
-            self.primaryjoin.accept_visitor(mapperutil.BinaryVisitor(visit_binary))
+            mapperutil.BinaryVisitor(visit_binary).traverse(self.primaryjoin)
 
             if len(self.foreign_keys) == 0:
                 raise exceptions.ArgumentError("Cant locate any foreign key columns in primary join condition '%s' for relationship '%s'.  Specify 'foreign_keys' argument to indicate which columns in the join condition are foreign." %(str(self.primaryjoin), str(self)))
             if self.secondaryjoin is not None:
-                self.secondaryjoin.accept_visitor(mapperutil.BinaryVisitor(visit_binary))
+                mapperutil.BinaryVisitor(visit_binary).traverse(self.secondaryjoin)
 
     def _determine_direction(self):
         """Determine our *direction*, i.e. do we represent one to
@@ -343,14 +343,14 @@ class PropertyLoader(StrategizedProperty):
         if self.loads_polymorphic:
             if self.secondaryjoin:
                 self.polymorphic_secondaryjoin = self.secondaryjoin.copy_container()
-                self.polymorphic_secondaryjoin.accept_visitor(sql_util.ClauseAdapter(self.mapper.select_table))
+                sql_util.ClauseAdapter(self.mapper.select_table).traverse(self.polymorphic_secondaryjoin)
                 self.polymorphic_primaryjoin = self.primaryjoin.copy_container()
             else:
                 self.polymorphic_primaryjoin = self.primaryjoin.copy_container()
                 if self.direction is sync.ONETOMANY:
-                    self.polymorphic_primaryjoin.accept_visitor(sql_util.ClauseAdapter(self.mapper.select_table, include=self.foreign_keys, equivalents=target_equivalents))
+                    sql_util.ClauseAdapter(self.mapper.select_table, include=self.foreign_keys, equivalents=target_equivalents).traverse(self.polymorphic_primaryjoin)
                 elif self.direction is sync.MANYTOONE:
-                    self.polymorphic_primaryjoin.accept_visitor(sql_util.ClauseAdapter(self.mapper.select_table, exclude=self.foreign_keys, equivalents=target_equivalents))
+                    sql_util.ClauseAdapter(self.mapper.select_table, exclude=self.foreign_keys, equivalents=target_equivalents).traverse(self.polymorphic_primaryjoin)
                 self.polymorphic_secondaryjoin = None
             # load "polymorphic" versions of the columns present in "remote_side" - this is
             # important for lazy-clause generation which goes off the polymorphic target selectable
@@ -411,11 +411,11 @@ class PropertyLoader(StrategizedProperty):
             else:
                 secondaryjoin = None
             if self.direction is sync.ONETOMANY:
-                primaryjoin.accept_visitor(sql_util.ClauseAdapter(parent.select_table, exclude=self.foreign_keys, equivalents=parent_equivalents))
+                sql_util.ClauseAdapter(parent.select_table, exclude=self.foreign_keys, equivalents=parent_equivalents).traverse(primaryjoin)
             elif self.direction is sync.MANYTOONE:
-                primaryjoin.accept_visitor(sql_util.ClauseAdapter(parent.select_table, include=self.foreign_keys, equivalents=parent_equivalents))
+                sql_util.ClauseAdapter(parent.select_table, include=self.foreign_keys, equivalents=parent_equivalents).traverse(primaryjoin)
             elif self.secondaryjoin:
-                primaryjoin.accept_visitor(sql_util.ClauseAdapter(parent.select_table, exclude=self.foreign_keys, equivalents=parent_equivalents))
+                sql_util.ClauseAdapter(parent.select_table, exclude=self.foreign_keys, equivalents=parent_equivalents).traverse(primaryjoin)
 
             if secondaryjoin is not None:
                 j = primaryjoin & secondaryjoin
diff --git a/lib/sqlalchemy/orm/query.py b/lib/sqlalchemy/orm/query.py
index a1c8b6af5..a0b520f33 100644
--- a/lib/sqlalchemy/orm/query.py
+++ b/lib/sqlalchemy/orm/query.py
@@ -775,7 +775,7 @@ class Query(object):
             # adapt the given WHERECLAUSE to adjust instances of this query's mapped 
             # table to be that of our select_table,
             # which may be the "polymorphic" selectable used by our mapper.
-            whereclause.accept_visitor(sql_util.ClauseAdapter(self.table))
+            sql_util.ClauseAdapter(self.table).traverse(whereclause)
 
             # if extra entities, adapt the criterion to those as well
             for m in self._entities:
@@ -783,7 +783,7 @@ class Query(object):
                     m = mapper.class_mapper(m)
                 if isinstance(m, mapper.Mapper):
                     table = m.select_table
-                    whereclause.accept_visitor(sql_util.ClauseAdapter(m.select_table))
+                    sql_util.ClauseAdapter(m.select_table).traverse(whereclause)
         
         # get/create query context.  get the ultimate compile arguments
         # from there
@@ -827,7 +827,7 @@ class Query(object):
                 order_by = util.to_list(order_by) or []
                 cf = sql_util.ColumnFinder()
                 for o in order_by:
-                    o.accept_visitor(cf)
+                    cf.traverse(o)
             else:
                 cf = []
 
diff --git a/lib/sqlalchemy/orm/strategies.py b/lib/sqlalchemy/orm/strategies.py
index 8e19be536..a295ed862 100644
--- a/lib/sqlalchemy/orm/strategies.py
+++ b/lib/sqlalchemy/orm/strategies.py
@@ -260,7 +260,7 @@ class LazyLoader(AbstractRelationLoader):
             class FindColumnInColumnClause(sql.ClauseVisitor):
                 def visit_column(self, c):
                     columns.append(c)
-            expr.accept_visitor(FindColumnInColumnClause())
+            FindColumnInColumnClause().traverse(expr)
             return len(columns) and columns[0] or None
         
         def col_in_collection(column, collection):
@@ -294,7 +294,7 @@ class LazyLoader(AbstractRelationLoader):
 
         lazywhere = primaryjoin.copy_container()
         li = mapperutil.BinaryVisitor(visit_binary)
-        lazywhere.accept_visitor(li)
+        li.traverse(lazywhere)
         
         if secondaryjoin is not None:
             secondaryjoin = secondaryjoin.copy_container()
@@ -363,16 +363,16 @@ class EagerLoader(AbstractRelationLoader):
                         eagerloader.secondary:self.eagersecondary
                         })
                 self.eagersecondaryjoin = eagerloader.polymorphic_secondaryjoin.copy_container()
-                self.eagersecondaryjoin.accept_visitor(self.aliasizer)
+                self.aliasizer.traverse(self.eagersecondaryjoin)
                 self.eagerprimary = eagerloader.polymorphic_primaryjoin.copy_container()
-                self.eagerprimary.accept_visitor(self.aliasizer)
+                self.aliasizer.traverse(self.eagerprimary)
             else:
                 self.eagerprimary = eagerloader.polymorphic_primaryjoin.copy_container()
                 self.aliasizer = sql_util.Aliasizer(self.target, aliases={self.target:self.eagertarget})
-                self.eagerprimary.accept_visitor(self.aliasizer)
+                self.aliasizer.traverse(self.eagerprimary)
 
             if parentclauses is not None:
-                self.eagerprimary.accept_visitor(parentclauses.aliasizer)
+                parentclauses.aliasizer.traverse(self.eagerprimary)
 
             if eagerloader.order_by:
                 self.eager_order_by = self._aliasize_orderby(eagerloader.order_by)
diff --git a/lib/sqlalchemy/orm/sync.py b/lib/sqlalchemy/orm/sync.py
index 68fa9cee1..8c70f8cf8 100644
--- a/lib/sqlalchemy/orm/sync.py
+++ b/lib/sqlalchemy/orm/sync.py
@@ -80,8 +80,7 @@ class ClauseSynchronizer(object):
                         self.syncrules.append(SyncRule(self.child_mapper, source_column, dest_column, dest_mapper=self.parent_mapper, issecondary=issecondary))
 
         rules_added = len(self.syncrules)
-        processor = BinaryVisitor(compile_binary)
-        sqlclause.accept_visitor(processor)
+        BinaryVisitor(compile_binary).traverse(sqlclause)
         if len(self.syncrules) == rules_added:
             raise exceptions.ArgumentError("No syncrules generated for join criterion " + str(sqlclause))