- added verbose activity to profiling.function_call_count

- simplified oracle non-ansi join generation, removed hooks from base compiler
- removed join() call from _label generation, fixed repeat label gen

1 files changed, 60 insertions, 50 deletions

diff --git a/lib/sqlalchemy/databases/oracle.py b/lib/sqlalchemy/databases/oracle.py
index 276397264..c601ad4e3 100644
--- a/lib/sqlalchemy/databases/oracle.py
+++ b/lib/sqlalchemy/databases/oracle.py
@@ -570,7 +570,9 @@ class _OuterJoinColumn(sql.ClauseElement):
     __visit_name__ = 'outer_join_column'
     def __init__(self, column):
         self.column = column
-
+    def _get_from_objects(self, **kwargs):
+        return []
+    
 class OracleCompiler(compiler.DefaultCompiler):
     """Oracle compiler modifies the lexical structure of Select
     statements to work under non-ANSI configured Oracle databases, if
@@ -609,36 +611,28 @@ class OracleCompiler(compiler.DefaultCompiler):
     def visit_join(self, join, **kwargs):
         if self.dialect.use_ansi:
             return compiler.DefaultCompiler.visit_join(self, join, **kwargs)
-
-        (where, parentjoin) = self.__wheres.get(join, (None, None))
-
-        class VisitOn(visitors.ClauseVisitor):
-            def visit_binary(s, binary):
-                if binary.operator == sql_operators.eq:
-                    if binary.left.table is join.right:
-                        binary.left = _OuterJoinColumn(binary.left)
-                    elif binary.right.table is join.right:
-                        binary.right = _OuterJoinColumn(binary.right)
-
-        if join.isouter:
-            if where is not None:
-                self.__wheres[join.left] = self.__wheres[parentjoin] = (sql.and_(VisitOn().traverse(join.onclause, clone=True), where), parentjoin)
-            else:
-                self.__wheres[join.left] = self.__wheres[join] = (VisitOn().traverse(join.onclause, clone=True), join)
         else:
-            if where is not None:
-                self.__wheres[join.left] = self.__wheres[parentjoin] = (sql.and_(join.onclause, where), parentjoin)
+            return self.process(join.left, asfrom=True) + ", " + self.process(join.right, asfrom=True)
+    
+    def _get_nonansi_join_whereclause(self, froms):
+        clauses = []
+        
+        def visit_join(join):
+            if join.isouter:
+                def visit_binary(binary):
+                    if binary.operator == sql_operators.eq:
+                        if binary.left.table is join.right:
+                            binary.left = _OuterJoinColumn(binary.left)
+                        elif binary.right.table is join.right:
+                            binary.right = _OuterJoinColumn(binary.right)
+                clauses.append(visitors.traverse(join.onclause, visit_binary=visit_binary, clone=True))
             else:
-                self.__wheres[join.left] = self.__wheres[join] = (join.onclause, join)
-
-        return self.process(join.left, asfrom=True) + ", " + self.process(join.right, asfrom=True)
-
-    def get_whereclause(self, f):
-        if f in self.__wheres:
-            return self.__wheres[f][0]
-        else:
-            return None
-
+                clauses.append(join.onclause)
+        
+        for f in froms:
+            visitors.traverse(f, visit_join=visit_join)
+        return sql.and_(*clauses)
+        
     def visit_outer_join_column(self, vc):
         return self.process(vc.column) + "(+)"
 
@@ -662,27 +656,43 @@ class OracleCompiler(compiler.DefaultCompiler):
         so tries to wrap it in a subquery with ``row_number()`` criterion.
         """
 
-        if not getattr(select, '_oracle_visit', None) and (select._limit is not None or select._offset is not None):
-            # to use ROW_NUMBER(), an ORDER BY is required.
-            orderby = self.process(select._order_by_clause)
-            if not orderby:
-                orderby = list(select.oid_column.proxies)[0]
-                orderby = self.process(orderby)
-
-            oldselect = select
-            select = select.column(sql.literal_column("ROW_NUMBER() OVER (ORDER BY %s)" % orderby).label("ora_rn")).order_by(None)
-            select._oracle_visit = True
-
-            limitselect = sql.select([c for c in select.c if c.key!='ora_rn'])
-            if select._offset is not None:
-                limitselect.append_whereclause("ora_rn>%d" % select._offset)
-                if select._limit is not None:
-                    limitselect.append_whereclause("ora_rn<=%d" % (select._limit + select._offset))
-            else:
-                limitselect.append_whereclause("ora_rn<=%d" % select._limit)
-            return self.process(limitselect, iswrapper=True, **kwargs)
-        else:
-            return compiler.DefaultCompiler.visit_select(self, select, **kwargs)
+        if not getattr(select, '_oracle_visit', None):
+            if not self.dialect.use_ansi:
+                if self.stack and 'from' in self.stack[-1]:
+                    existingfroms = self.stack[-1]['from']
+                else:
+                    existingfroms = None
+
+                froms = select._get_display_froms(existingfroms)
+                whereclause = self._get_nonansi_join_whereclause(froms)
+                if whereclause:
+                    select = select.where(whereclause)
+                    select._oracle_visit = True
+                
+            if select._limit is not None or select._offset is not None:
+                # to use ROW_NUMBER(), an ORDER BY is required.
+                orderby = self.process(select._order_by_clause)
+                if not orderby:
+                    orderby = list(select.oid_column.proxies)[0]
+                    orderby = self.process(orderby)
+
+                select = select.column(sql.literal_column("ROW_NUMBER() OVER (ORDER BY %s)" % orderby).label("ora_rn")).order_by(None)
+                select._oracle_visit = True
+                
+                limitselect = sql.select([c for c in select.c if c.key!='ora_rn'])
+                limitselect._oracle_visit = True
+                limitselect._is_wrapper = True
+                
+                if select._offset is not None:
+                    limitselect.append_whereclause("ora_rn>%d" % select._offset)
+                    if select._limit is not None:
+                        limitselect.append_whereclause("ora_rn<=%d" % (select._limit + select._offset))
+                else:
+                    limitselect.append_whereclause("ora_rn<=%d" % select._limit)
+                select = limitselect
+        
+        kwargs['iswrapper'] = getattr(select, '_is_wrapper', False)
+        return compiler.DefaultCompiler.visit_select(self, select, **kwargs)
 
     def limit_clause(self, select):
         return ""