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, 14 insertions, 9 deletions

diff --git a/lib/sqlalchemy/future/selectable.py b/lib/sqlalchemy/future/selectable.py
index 2b76245e0..58fced887 100644
--- a/lib/sqlalchemy/future/selectable.py
+++ b/lib/sqlalchemy/future/selectable.py
@@ -56,7 +56,9 @@ class Select(_LegacySelect):
 
         self = cls.__new__(cls)
         self._raw_columns = [
-            coercions.expect(roles.ColumnsClauseRole, ent, apply_plugins=self)
+            coercions.expect(
+                roles.ColumnsClauseRole, ent, apply_propagate_attrs=self
+            )
             for ent in entities
         ]
 
@@ -71,9 +73,9 @@ class Select(_LegacySelect):
 
     def _filter_by_zero(self):
         if self._setup_joins:
-            meth = SelectState.get_plugin_classmethod(
-                self, "determine_last_joined_entity"
-            )
+            meth = SelectState.get_plugin_class(
+                self
+            ).determine_last_joined_entity
             _last_joined_entity = meth(self)
             if _last_joined_entity is not None:
                 return _last_joined_entity
@@ -106,7 +108,7 @@ class Select(_LegacySelect):
 
         """
         target = coercions.expect(
-            roles.JoinTargetRole, target, apply_plugins=self
+            roles.JoinTargetRole, target, apply_propagate_attrs=self
         )
         self._setup_joins += (
             (target, onclause, None, {"isouter": isouter, "full": full}),
@@ -123,12 +125,15 @@ class Select(_LegacySelect):
 
 
         """
+        # note the order of parsing from vs. target is important here, as we
+        # are also deriving the source of the plugin (i.e. the subject mapper
+        # in an ORM query) which should favor the "from_" over the "target"
 
-        target = coercions.expect(
-            roles.JoinTargetRole, target, apply_plugins=self
-        )
         from_ = coercions.expect(
-            roles.FromClauseRole, from_, apply_plugins=self
+            roles.FromClauseRole, from_, apply_propagate_attrs=self
+        )
+        target = coercions.expect(
+            roles.JoinTargetRole, target, apply_propagate_attrs=self
         )
 
         self._setup_joins += (