pep-484: the pep-484ening, SQL part three

hitting DML which is causing us to open up the
ColumnCollection structure a bit, as we do put anonymous
column expressions with None here.  However, we still want
Table /TableClause to have named column collections that
don't return None, so parametrize the "key" in this
collection also.

* rename some "immutable" elements to "readonly".  we change
  the contents of immutablecolumncollection underneath, so it's
  not "immutable"

Change-Id: I2593995a4e5c6eae874bed5bf76117198be8ae97

1 files changed, 3 insertions, 87 deletions

diff --git a/lib/sqlalchemy/sql/_dml_constructors.py b/lib/sqlalchemy/sql/_dml_constructors.py
index a8c24413f..835819bac 100644
--- a/lib/sqlalchemy/sql/_dml_constructors.py
+++ b/lib/sqlalchemy/sql/_dml_constructors.py
@@ -112,82 +112,10 @@ def update(table):
      object representing the database
      table to be updated.
 
-    :param whereclause: Optional SQL expression describing the ``WHERE``
-     condition of the ``UPDATE`` statement; is equivalent to using the
-     more modern :meth:`~Update.where()` method to specify the ``WHERE``
-     clause.
-
-    :param values:
-      Optional dictionary which specifies the ``SET`` conditions of the
-      ``UPDATE``.  If left as ``None``, the ``SET``
-      conditions are determined from those parameters passed to the
-      statement during the execution and/or compilation of the
-      statement.   When compiled standalone without any parameters,
-      the ``SET`` clause generates for all columns.
-
-      Modern applications may prefer to use the generative
-      :meth:`_expression.Update.values` method to set the values of the
-      UPDATE statement.
-
-    :param inline:
-      if True, SQL defaults present on :class:`_schema.Column` objects via
-      the ``default`` keyword will be compiled 'inline' into the statement
-      and not pre-executed.  This means that their values will not
-      be available in the dictionary returned from
-      :meth:`_engine.CursorResult.last_updated_params`.
-
-    :param preserve_parameter_order: if True, the update statement is
-      expected to receive parameters **only** via the
-      :meth:`_expression.Update.values` method,
-      and they must be passed as a Python
-      ``list`` of 2-tuples. The rendered UPDATE statement will emit the SET
-      clause for each referenced column maintaining this order.
-
-      .. versionadded:: 1.0.10
-
-      .. seealso::
-
-        :ref:`updates_order_parameters` - illustrates the
-        :meth:`_expression.Update.ordered_values` method.
-
-    If both ``values`` and compile-time bind parameters are present, the
-    compile-time bind parameters override the information specified
-    within ``values`` on a per-key basis.
-
-    The keys within ``values`` can be either :class:`_schema.Column`
-    objects or their string identifiers (specifically the "key" of the
-    :class:`_schema.Column`, normally but not necessarily equivalent to
-    its "name").  Normally, the
-    :class:`_schema.Column` objects used here are expected to be
-    part of the target :class:`_schema.Table` that is the table
-    to be updated.  However when using MySQL, a multiple-table
-    UPDATE statement can refer to columns from any of
-    the tables referred to in the WHERE clause.
-
-    The values referred to in ``values`` are typically:
-
-    * a literal data value (i.e. string, number, etc.)
-    * a SQL expression, such as a related :class:`_schema.Column`,
-      a scalar-returning :func:`_expression.select` construct,
-      etc.
-
-    When combining :func:`_expression.select` constructs within the
-    values clause of an :func:`_expression.update`
-    construct, the subquery represented
-    by the :func:`_expression.select` should be *correlated* to the
-    parent table, that is, providing criterion which links the table inside
-    the subquery to the outer table being updated::
-
-        users.update().values(
-                name=select(addresses.c.email_address).\
-                        where(addresses.c.user_id==users.c.id).\
-                        scalar_subquery()
-            )
 
     .. seealso::
 
-        :ref:`inserts_and_updates` - SQL Expression
-        Language Tutorial
+        :ref:`tutorial_core_update_delete` - in the :ref:`unified_tutorial`
 
 
     """
@@ -210,24 +138,12 @@ def delete(table):
     :meth:`_expression.TableClause.delete` method on
     :class:`_schema.Table`.
 
-    .. seealso::
-
-        :ref:`inserts_and_updates` - in the
-        :ref:`1.x tutorial <sqlexpression_toplevel>`
-
-        :ref:`tutorial_core_update_delete` - in the :ref:`unified_tutorial`
-
-
     :param table: The table to delete rows from.
 
-    :param whereclause: Optional SQL expression describing the ``WHERE``
-     condition of the ``DELETE`` statement; is equivalent to using the
-     more modern :meth:`~Delete.where()` method to specify the ``WHERE``
-     clause.
-
     .. seealso::
 
-        :ref:`deletes` - SQL Expression Tutorial
+        :ref:`tutorial_core_update_delete` - in the :ref:`unified_tutorial`
+
 
     """
     return Delete(table)