Add future=True to create_engine/Session; unify select()

Several weeks of using the future_select() construct
has led to the proposal there be just one select() construct
again which features the new join() method, and otherwise accepts
both the 1.x and 2.x argument styles.   This would make
migration simpler and reduce confusion.

However, confusion may be increased by the fact that select().join()
is different  Current thinking is we may be better off
with a few hard behavioral changes to old and relatively unknown APIs
rather than trying to play both sides within two extremely similar
but subtly different APIs.  At the moment, the .join() thing seems
to be the only behavioral change that occurs without the user
taking any explicit steps.   Session.execute() will still
behave the old way as we are adding a future flag.

This change also adds the "future" flag to Session() and
session.execute(), so that interpretation of the incoming statement,
as well as that the new style result is returned, does not
occur for existing applications unless they add the use
of this flag.

The change in general is moving the "removed in 2.0" system
further along where we want the test suite to fully pass
even if the SQLALCHEMY_WARN_20 flag is set.

Get many tests to pass when SQLALCHEMY_WARN_20 is set; this
should be ongoing after this patch merges.

Improve the RemovedIn20 warning; these are all deprecated
"since" 1.4, so ensure that's what the messages read.
Make sure the inforamtion link is on all warnings.
Add deprecation warnings for parameters present and
add warnings to all FromClause.select() types of methods.

Fixes: #5379
Fixes: #5284
Change-Id: I765a0b912b3dcd0e995426427d8bb7997cbffd51
References: #5159

1 files changed, 0 insertions, 165 deletions

diff --git a/lib/sqlalchemy/future/selectable.py b/lib/sqlalchemy/future/selectable.py
deleted file mode 100644
index 9d0ae7c89..000000000
--- a/lib/sqlalchemy/future/selectable.py
+++ /dev/null
@@ -1,165 +0,0 @@
-from ..sql import coercions
-from ..sql import roles
-from ..sql.base import _generative
-from ..sql.selectable import GenerativeSelect
-from ..sql.selectable import Select as _LegacySelect
-from ..sql.selectable import SelectState
-from ..sql.util import _entity_namespace_key
-
-
-class Select(_LegacySelect):
-    _is_future = True
-    _setup_joins = ()
-    _legacy_setup_joins = ()
-    inherit_cache = True
-
-    @classmethod
-    def _create_select(cls, *entities):
-        raise NotImplementedError("use _create_future_select")
-
-    @classmethod
-    def _create_future_select(cls, *entities):
-        r"""Construct a new :class:`_expression.Select` using the 2.
-        x style API.
-
-        .. versionadded:: 2.0 - the :func:`_future.select` construct is
-           the same construct as the one returned by
-           :func:`_expression.select`, except that the function only
-           accepts the "columns clause" entities up front; the rest of the
-           state of the SELECT should be built up using generative methods.
-
-        Similar functionality is also available via the
-        :meth:`_expression.FromClause.select` method on any
-        :class:`_expression.FromClause`.
-
-        .. seealso::
-
-            :ref:`coretutorial_selecting` - Core Tutorial description of
-            :func:`_expression.select`.
-
-        :param \*entities:
-          Entities to SELECT from.  For Core usage, this is typically a series
-          of :class:`_expression.ColumnElement` and / or
-          :class:`_expression.FromClause`
-          objects which will form the columns clause of the resulting
-          statement.   For those objects that are instances of
-          :class:`_expression.FromClause` (typically :class:`_schema.Table`
-          or :class:`_expression.Alias`
-          objects), the :attr:`_expression.FromClause.c`
-          collection is extracted
-          to form a collection of :class:`_expression.ColumnElement` objects.
-
-          This parameter will also accept :class:`_expression.TextClause`
-          constructs as
-          given, as well as ORM-mapped classes.
-
-        """
-
-        self = cls.__new__(cls)
-        self._raw_columns = [
-            coercions.expect(
-                roles.ColumnsClauseRole, ent, apply_propagate_attrs=self
-            )
-            for ent in entities
-        ]
-
-        GenerativeSelect.__init__(self)
-
-        return self
-
-    def filter(self, *criteria):
-        """A synonym for the :meth:`_future.Select.where` method."""
-
-        return self.where(*criteria)
-
-    def _exported_columns_iterator(self):
-        meth = SelectState.get_plugin_class(self).exported_columns_iterator
-        return meth(self)
-
-    def _filter_by_zero(self):
-        if self._setup_joins:
-            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
-
-        if self._from_obj:
-            return self._from_obj[0]
-
-        return self._raw_columns[0]
-
-    def filter_by(self, **kwargs):
-        r"""Apply the given filtering criterion as a WHERE clause
-        to this select.
-
-        """
-        from_entity = self._filter_by_zero()
-
-        clauses = [
-            _entity_namespace_key(from_entity, key) == value
-            for key, value in kwargs.items()
-        ]
-        return self.filter(*clauses)
-
-    @property
-    def column_descriptions(self):
-        """Return a 'column descriptions' structure which may be
-        plugin-specific.
-
-        """
-        meth = SelectState.get_plugin_class(self).get_column_descriptions
-        return meth(self)
-
-    @_generative
-    def join(self, target, onclause=None, isouter=False, full=False):
-        r"""Create a SQL JOIN against this :class:`_expression.Select`
-        object's criterion
-        and apply generatively, returning the newly resulting
-        :class:`_expression.Select`.
-
-
-        """
-        target = coercions.expect(
-            roles.JoinTargetRole, target, apply_propagate_attrs=self
-        )
-        if onclause is not None:
-            onclause = coercions.expect(roles.OnClauseRole, onclause)
-        self._setup_joins += (
-            (target, onclause, None, {"isouter": isouter, "full": full}),
-        )
-
-    @_generative
-    def join_from(
-        self, from_, target, onclause=None, isouter=False, full=False
-    ):
-        r"""Create a SQL JOIN against this :class:`_expression.Select`
-        object's criterion
-        and apply generatively, returning the newly resulting
-        :class:`_expression.Select`.
-
-
-        """
-        # 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"
-
-        from_ = coercions.expect(
-            roles.FromClauseRole, from_, apply_propagate_attrs=self
-        )
-        target = coercions.expect(
-            roles.JoinTargetRole, target, apply_propagate_attrs=self
-        )
-
-        self._setup_joins += (
-            (target, onclause, from_, {"isouter": isouter, "full": full}),
-        )
-
-    def outerjoin(self, target, onclause=None, full=False):
-        """Create a left outer join.
-
-
-
-        """
-        return self.join(target, onclause=onclause, isouter=True, full=full,)