Convert execution to move through Session

This patch replaces the ORM execution flow with a
single pathway through Session.execute() for all queries,
including Core and ORM.

Currently included is full support for ORM Query,
Query.from_statement(), select(), as well as the
baked query and horizontal shard systems.  Initial
changes have also been made to the dogpile caching
example, which like baked query makes use of a
new ORM-specific execution hook that replaces the
use of both QueryEvents.before_compile() as well
as Query._execute_and_instances() as the central
ORM interception hooks.

select() and Query() constructs alike can be passed to
Session.execute() where they will return ORM
results in a Results object.   This API is currently
used internally by Query.   Full support for
Session.execute()->results to behave in a fully
2.0 fashion will be in later changesets.

bulk update/delete with ORM support will also
be delivered via the update() and delete()
constructs, however these have not yet been adapted
to the new system and may follow in a subsequent
update.

Performance is also beginning to lag as of this
commit and some previous ones.   It is hoped that
a few central functions such as the coercions
functions can be rewritten in C to re-gain
performance.  Additionally, query caching
is now available and some subsequent patches
will attempt to cache more of the per-execution
work from the ORM layer, e.g. column getters
and adapters.

This patch also contains initial "turn on" of the
caching system enginewide via the query_cache_size
parameter to create_engine(). Still defaulting at
zero for "no caching".   The caching system still
needs adjustments in order to gain adequate performance.

Change-Id: I047a7ebb26aa85dc01f6789fac2bff561dcd555d

1 files changed, 4 insertions, 12 deletions

diff --git a/lib/sqlalchemy/dialects/oracle/base.py b/lib/sqlalchemy/dialects/oracle/base.py
index dd7d6a4d1..481ea7263 100644
--- a/lib/sqlalchemy/dialects/oracle/base.py
+++ b/lib/sqlalchemy/dialects/oracle/base.py
@@ -975,16 +975,8 @@ class OracleCompiler(compiler.SQLCompiler):
 
         return "RETURNING " + ", ".join(columns) + " INTO " + ", ".join(binds)
 
-    def _TODO_visit_compound_select(self, select):
-        """Need to determine how to get ``LIMIT``/``OFFSET`` into a
-        ``UNION`` for Oracle.
-        """
-        pass
-
-    def visit_select(self, select, **kwargs):
-        """Look for ``LIMIT`` and OFFSET in a select statement, and if
-        so tries to wrap it in a subquery with ``rownum`` criterion.
-        """
+    def translate_select_structure(self, select_stmt, **kwargs):
+        select = select_stmt
 
         if not getattr(select, "_oracle_visit", None):
             if not self.dialect.use_ansi:
@@ -1003,7 +995,7 @@ class OracleCompiler(compiler.SQLCompiler):
                 # https://blogs.oracle.com/oraclemagazine/\
                 # on-rownum-and-limiting-results
 
-                kwargs["select_wraps_for"] = orig_select = select
+                orig_select = select
                 select = select._generate()
                 select._oracle_visit = True
 
@@ -1136,7 +1128,7 @@ class OracleCompiler(compiler.SQLCompiler):
                     offsetselect._for_update_arg = for_update
                     select = offsetselect
 
-        return compiler.SQLCompiler.visit_select(self, select, **kwargs)
+        return select
 
     def limit_clause(self, select, **kw):
         return ""