Revert "Implement support for functions as FROM with columns clause support"

This reverts commit 05a31f2.

Atom has this little button called "push" and just pushes to master,
I wasn't even *on* master.  oops

Author: zzzeek

doc/build/core/functions.rst

@@ -19,10 +19,6 @@ unknown to SQLAlchemy, built-in or user defined. The section here only
 describes those functions where SQLAlchemy already knows what argument and
 return types are in use.
 
-.. seealso::
-
-    :ref:`tutorial_functions` - in the :ref:`unified_tutorial`
-
 .. automodule:: sqlalchemy.sql.functions
    :members:
    :undoc-members:

doc/build/tutorial/data.rst

@@ -797,9 +797,6 @@ we call upon the name ``count()`` name::
     >>> print(count_fn)
     {opensql}count(user_account.id)
 
-SQL functions are described in more detail later in this tutorial at
-:ref:`tutorial_functions`.
-
 When using aggregate functions in SQL, the GROUP BY clause is essential in that
 it allows rows to be partitioned into groups where aggregate functions will
 be applied to each group individually.  When requesting non-aggregated columns
@@ -1281,286 +1278,6 @@ clause:
     [('patrick',)]
     {opensql}ROLLBACK{stop}
 
-.. _tutorial_functions:
-
-Working with SQL Functions
-^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-First introduced earlier in this section at :ref:`tutorial_group_by_w_aggregates`,
-the :data:`_sql.func` object serves as a factory for creating new
-:class:`_functions.Function` objects, which when used in a construct
-like :func:`_sql.select`, produce a SQL function display, typically
-consisting of a name, some parenthesis (although not always), and possibly
-some arguments.   Examples of typical SQL functions include:
-
-* the ``count()`` function, an aggregate function which counts how many
-  rows are returned::
-
-    .. sourcecode:: pycon+sql
-
-        >>> stmt = select(func.count()).select_from(user_table)
-        >>> with engine.connect() as conn:
-        ...     result = conn.execute(stmt)
-        ...     print(result.all())
-        {opensql}BEGIN (implicit)
-        SELECT count(*) AS count_1
-        FROM user_account
-        [...] ()
-        [(3,)]
-        ROLLBACK
-
-  ..
-
-* the ``lower()`` function, a string function that converts a string to
-  lower case::
-
-    .. sourcecode:: pycon+sql
-
-        >>> stmt = select(func.lower("A String With Much UPPERCASE"))
-        >>> with engine.connect() as conn:
-        ...     print(conn.scalar(stmt))
-        {opensql}BEGIN (implicit)
-        SELECT lower(?) AS lower_1
-        [...] ('A String With Much UPPERCASE',)
-        a string with much uppercase
-        ROLLBACK
-
-  ..
-
-* the ``now()`` function, which provides for the current date
-  and time; as this is a common function, SQLAlhemy knows how to render this
-  differently for each backend, in the case of SQLite using the
-  CURRENT_TIMESTAMP function::
-
-    .. sourcecode:: pycon+sql
-
-        >>> stmt = select(func.now())
-        >>> with engine.connect() as conn:
-        ...     result = conn.execute(stmt)
-        ...     print(result.all())
-        {opensql}BEGIN (implicit)
-        SELECT CURRENT_TIMESTAMP AS now_1
-        [...] ()
-        [(datetime.datetime(...),)]
-        ROLLBACK
-
-  ..
-
-As most database backends feature dozens if not hundreds of different SQL
-functions, the :data:`_sql.func` tries to be as liberal as possible in what
-it accepts.  Any name that is passed is automatically considered to be a
-SQL function that will render in a generic way::
-
-    >>> print(select(func.some_crazy_function(user_table.c.name, 17)))
-    SELECT some_crazy_function(user_account.name, :some_crazy_function_2) AS some_crazy_function_1
-    FROM user_account
-
-At the same time, a relatively small set of extremely common SQL functions
-such as :class:`_functions.now`, :class:`_functions.max`, :class:`_functions.concat`
-include pre-packaged versions of themselves which provide for proper typing
-information as well as backend-specific SQL generation in some cases::
-
-    >>> from sqlalchemy.dialects import postgresql, oracle
-    >>> print(select(func.now()).compile(dialect=postgresql.dialect()))
-    SELECT now() AS now_1
-    >>> print(select(func.now()).compile(dialect=oracle.dialect()))
-    SELECT CURRENT_TIMESTAMP AS now_1 FROM DUAL
-
-Functions Have Return Types
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-As functions are column expressions, they also have datatypes.  These return
-types are significant when making use of the function expression in the
-context of a larger expression; that is, math operators will work better
-when the datatype of the expression is something like :class:`_types.Integer`
-or :class:`_types.Numeric`, JSON accessors in order to work need to be using
-a type such as :class:`_types.JSON`.
-
-The return type of the function may also be significant when executing a
-statement and getting rows back, for those cases where SQLAlchemy has to
-apply result-set processing.  A prime example of this are date-related
-functions on SQLite.
-
-For common aggregate functions like :class:`_functions.count`,
-:class:`_functions.max`, :class:`_functions.min` as well as date functions like
-:class:`_functions.now`, string functions like :class:`_functions.concat`, the
-return type is set up appropriately, sometimes based on usage.   The
-:class:`_functions.max` function and similar ones will set up the return type
-based on the argument given::
-
-    >>> m1 = func.max(Column("some_int", Integer))
-    >>> m1.type
-    Integer()
-
-    >>> m2 = func.max(Column("some_str", String))
-    >>> m2.type
-    String()
-
-Date and time functions typically return :class:`_types.DateTime` or
-:class:`_types.Date`::
-
-    >>> func.now().type
-    DateTime()
-    >>> func.current_date().type
-    Date()
-
-A known string function such as :class:`_ will know to return :class:`_types.String`::
-
-    >>> func.concat("x", "y").type
-    String()
-
-However, for the vast majority of SQL functions, SQLAlchemy does not have them
-explicitly present in it's very small list of known functions.  For example,
-while there is typically no issue using SQL functions ``func.lower()``
-and ``func.upper()`` to convert the casing of strings, SQLAlchemy doesn't
-actually know about these functions, so they have a "null" return type::
-
-    >>> func.upper("lowercase").type
-    NullType()
-
-For simple functions like ``upper`` and ``lower``, the issue is not significant,
-but when using a SQL function where the return type is important (most typically
-involving PostgreSQL JSON or ARRAY functions, SQLite date-related functions),
-we can pass the type using ``type_=<type>``, such as::
-
-    >>> from sqlalchemy import JSON
-    >>> json_expr = func.json_extract_path('{"key1":{"key2":99}}','key1', type_=JSON)
-    >>> stmt = select(json_expr["key2"])
-    >>> print(stmt.compile(dialect=postgresql.dialect()))
-    SELECT json_extract_path(%(json_extract_path_1)s, %(json_extract_path_2)s) -> %(json_extract_path_3)s AS anon_1
-
-Above, the ``json_extract_path()`` function object would not be able to deliver
-the expression ``json_expr["key2"]`` without knowing that its return type
-should be using :class:`_types.JSON`.
-
-Using Window Functions
-~~~~~~~~~~~~~~~~~~~~~~
-
-A window function is a special use of a SQL aggregate function which calculates
-the aggregate value over the rows being returned in a group as the individual
-result rows are processed.  Whereas a function like ``MAX()`` will give you
-the highest value of a column within a set of rows, using the same function
-as a "window function" will given you the highest value for each row,
-*as of that row*.
-
-In SQL, window functions allow one to specify the rows over which the
-function should be applied, a "partition" value which considers the window
-over different sub-sets of rows, and an "order by" expression which importantly
-indicates the order in which rows should be applied to the aggregate function.
-
-All SQL functions include a method :meth:`_functions.Function.over` which
-grants the window function, or "OVER", syntax.  A common function used with
-window functions is the ``row_number()`` function which simply counts
-rows.  We may partition this row count against user name to number the
-email addresses of individual users::
-
-    .. sourcecode:: pycon+sql
-
-        >>> stmt = select(
-        ...     func.row_number().over(partition_by=user_table.c.name),
-        ...     user_table.c.name,
-        ...     address_table.c.email_address).select_from(user_table).join(address_table)
-        >>> with engine.connect() as conn:
-        ...     result = conn.execute(stmt)
-        ...     print(result.all())
-        {opensql} BEGIN (implicit)
-        SELECT row_number() OVER (PARTITION BY user_account.name) AS anon_1, user_account.name, address.email_address
-        FROM user_account JOIN address ON user_account.id = address.user_id
-        [...] ()
-        [(1, 'sandy', '[email protected]'), (2, 'sandy', '[email protected]'), (1, 'spongebob', '[email protected]')]
-        ROLLBACK
-
-Within :meth:`_functions.Function.over`, the :paramref:`_functions.Function.over.order_by`
-and :paramref:`_functions.Function.over.partition_by` set up the ORDER BY and
-PARTITION BY options.
-
-Special Modifiers WITHIN GROUP, FILTER
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The "WITHIN GROUP" SQL syntax is used in conjunction with an "ordered set"
-or a "hypothetical set" aggregate
-function.  Common "ordered set" functions include ``percentile_cont()``
-and ``rank()``.  SQLAlchemy includes built in implementations
-:class:`_functions.rank`, :class:`_functions.dense_rank`,
-:class:`_functions.mode`, :class:`_functions.percentile_cont` and
-:class:`_functions.percentile_disc` which include a :meth:`_functions.FunctionElement.within_group`
-method::
-
-    >>> print(
-    ...     func.unnest(
-    ...         func.percentile_disc([0.25,0.5,0.75,1]).within_group(user_table.c.name)
-    ...     )
-    ... )
-    unnest(percentile_disc(:percentile_disc_1) WITHIN GROUP (ORDER BY user_account.name))
-
-"FILTER" is supported by some backends to limit the range of an aggregate function to a
-particular subset of rows compared to the total range of rows returned::
-
-    >>> stmt = select(
-    ...     func.count(address_table.c.email_address).filter(user_table.c.name == 'sandy'),
-    ...     func.count(address_table.c.email_address).filter(user_table.c.name == 'spongebob')
-    ... ).select_from(user_table).join(address_table)
-    >>> with engine.connect() as conn:
-    ...     result = conn.execute(stmt)
-    ...     print(result.all())
-    {opensql}BEGIN (implicit)
-    SELECT count(address.email_address) FILTER (WHERE user_account.name = ?) AS anon_1,
-    count(address.email_address) FILTER (WHERE user_account.name = ?) AS anon_2
-    FROM user_account JOIN address ON user_account.id = address.user_id
-    [...] ('sandy', 'spongebob')
-    [(2, 1)]
-    ROLLBACK
-
-
-Table-Valued Functions
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Table-valued SQL functions support a scalar representation that contains
-named sub-elements.   Often used for JSON functions as well as functions like
-``generate_series()``, the table-valued function is specified in the FROM
-clause, and is then referred towards as a table, or sometimes even as a
-column.    Functions of this form are prominent within the PostgreSQL database
-and are also supported by SQLite.
-
-To provide support for these, SQLAlchemy provides the
-:meth:`_functions.FunctionElement.alias` method, which will convert a
-:func:`_sql.func` object into a FROM clause.  From there, it can then
-be referenced directly in the columns or WHERE clause of a SELECT using
-the ``.c`` collection normally.   When using the ``.c`` collection, the
-names of columns desired should be passed to the original function using
-the :paramref:`_functions.Function.table_valued` parameter::
-
-    >>> stmt = select(
-    ...     func.json_each(
-    ...         '["one", "two", "three"]',
-    ...     ).table_valued("value").alias()
-    ... )
-    >>> with engine.connect() as conn:
-    ...     result = conn.execute(stmt)
-    ...     print(result.all())
-    BEGIN (implicit)
-    SELECT anon_1.value
-    FROM json_each(?) AS anon_1
-    [...] ('["one", "two", "three"]',)
-    [('one',), ('two',), ('three',)]
-    ROLLBACK
-
-A scalar-valued function such as PostgreSQL's ``json_array_elements`` may
-also be referred towards as itself in the columns clause, using the special
-accessor ``.column``::
-
-    >>> fn = func.json_array_elements(
-    ...     '[{"c1": 1, "c2": 2}, {"c1": 5, "c2": 10}]',
-    ...      type_=JSON).alias("result_elem")
-    >>> stmt = select(fn.column['c1'], fn.column['c2'])
-    >>> print(stmt)
-    SELECT result_elem[:result_elem_1] AS anon_1, result_elem[:result_elem_2] AS anon_2
-    FROM json_array_elements(:json_array_elements_1) AS result_elem
-
-Above, when we produce the ``json_array_elements()`` function, we provide
-the :class:`_types.JSON` datatype as its return type,  so that we may use
-Python ``__getitem__()`` access on it, e.g. ``fn.column['c1']``.
-
 
 .. rst-class:: core-header, orm-addin
 

lib/sqlalchemy/dialects/oracle/base.py

@@ -924,19 +924,6 @@ def function_argspec(self, fn, **kw):
         else:
             return ""
 
-    def visit_function(self, func, **kw):
-        text = super(OracleCompiler, self).visit_function(func, **kw)
-        if kw.get("asfrom", False):
-            text = "TABLE (%s)" % func
-        return text
-
-    def visit_table_valued_column(self, element, **kw):
-        text = super(OracleCompiler, self).visit_table_valued_column(
-            element, **kw
-        )
-        text = "COLUMN_VALUE " + text
-        return text
-
     def default_from(self):
         """Called when a ``SELECT`` statement has no froms,
         and no ``FROM`` clause is to be appended.

lib/sqlalchemy/sql/coercions.py

@@ -431,20 +431,6 @@ def _literal_coercion(
             except exc.ArgumentError as err:
                 self._raise_for_expected(element, err=err)
 
-    def _raise_for_expected(self, element, argname=None, resolved=None, **kw):
-        if isinstance(element, roles.AnonymizedFromClauseRole):
-            advice = (
-                "To create a "
-                "column expression from a FROM clause row "
-                "as a whole, use the .record() method."
-            )
-        else:
-            advice = None
-
-        return super(ExpressionElementImpl, self)._raise_for_expected(
-            element, argname=argname, resolved=resolved, advice=advice, **kw
-        )
-
 
 class BinaryElementImpl(ExpressionElementImpl, RoleImpl):
 
@@ -611,13 +597,6 @@ class ColumnArgumentOrKeyImpl(_ReturnsStringKey, RoleImpl):
     __slots__ = ()
 
 
-class StrAsPlainColumnImpl(_CoerceLiterals, RoleImpl):
-    __slots__ = ()
-
-    def _text_coercion(self, element, argname=None):
-        return elements.ColumnClause(element)
-
-
 class ByOfImpl(_CoerceLiterals, _ColumnCoercions, RoleImpl, roles.ByOfRole):
 
     __slots__ = ()