'specify a fixed VALUES clause for an INSERT statement, or the SET
clause for an UPDATE.
Note that the :class:`.Insert` and :class:`.Update` constructs support
per-execution time formatting of the VALUES and/or SET clauses,
based on the arguments passed to :meth:`.Connection.execute`.  However,
the :meth:`.ValuesBase.values` method can be used to "fix" a particular
set of parameters into the statement.
Multiple calls to :meth:`.ValuesBase.values` will produce a new
construct, each one with the parameter list modified to include
the new parameters sent.  In the typical case of a single
dictionary of parameters, the newly passed keys will replace
the same keys in the previous construct.  In the case of a list-based
"multiple values" construct, each new list of values is extended
onto the existing list of values.
:param \**kwargs: key value pairs representing the string key
of a :class:`.Column` mapped to the value to be rendered into the
VALUES or SET clause::
users.insert().values(name="some name")
users.update().where(users.c.id==5).values(name="some name")
:param \*args: Alternatively, a dictionary, tuple or list
of dictionaries or tuples can be passed as a single positional
argument in order to form the VALUES or
SET clause of the statement.  The single dictionary form
works the same as the kwargs form::
users.insert().values({"name": "some name"})
If a tuple is passed, the tuple should contain the same number
of columns as the target :class:`.Table`::
users.insert().values((5, "some name"))
The :class:`.Insert` construct also supports multiply-rendered VALUES
construct, for those backends which support this SQL syntax
(SQLite, Postgresql, MySQL).  This mode is indicated by passing a list
of one or more dictionaries/tuples::
users.insert().values([
{"name": "some name"},
{"name": "some other name"},
{"name": "yet another name"},
In the case of an :class:`.Update`
construct, only the single dictionary/tuple form is accepted,
else an exception is raised.  It is also an exception case to
attempt to mix the single-/multiple- value styles together,
either through multiple :meth:`.ValuesBase.values` calls
or by sending a list + kwargs at the same time.
.. note::
Passing a multiple values list is *not* the same
as passing a multiple values list to the :meth:`.Connection.execute`
method.  Passing a list of parameter sets to :meth:`.ValuesBase.values`
produces a construct of this form::
INSERT INTO table (col1, col2, col3) VALUES
(col1_0, col2_0, col3_0),
(col1_1, col2_1, col3_1),
whereas a multiple list passed to :meth:`.Connection.execute`
has the effect of using the DBAPI
`executemany() <http://www.python.org/dev/peps/pep-0249/#id18>`_
method, which provides a high-performance system of invoking
a single-row INSERT statement many times against a series
of parameter sets.   The "executemany" style is supported by
all database backends, as it does not depend on a special SQL
syntax.
.. versionadded:: 0.8
Support for multiple-VALUES INSERT statements.
.. seealso::
:ref:`inserts_and_updates` - SQL Expression
Language Tutorial
:func:`~.expression.insert` - produce an ``INSERT`` statement
:func:`~.expression.update` - produce an ``UPDATE`` statement'

@_generative
def values(self, *args, **kwargs):

    if (self.select is not None):
        raise exc.InvalidRequestError('This    construct    already    inserts    from    a    SELECT')
    if (self._has_multi_parameters and kwargs):
        raise exc.InvalidRequestError('This    construct    already    has    multiple    parameter    sets.')
    if args:
        if (len(args) > 1):
            raise exc.ArgumentError('Only    a    single    dictionary/tuple    or    list    of    dictionaries/tuples    is    accepted    positionally.')
        v = args[0]
    else:
        v = {}
    if (self.parameters is None):
        (self.parameters, self._has_multi_parameters) = self._process_colparams(v)
    elif self._has_multi_parameters:
        self.parameters = list(self.parameters)
        (p, self._has_multi_parameters) = self._process_colparams(v)
        if (not self._has_multi_parameters):
            raise exc.ArgumentError("Can't    mix    single-values    and    multiple    values    formats    in    one    statement")
        self.parameters.extend(p)
    else:
        self.parameters = self.parameters.copy()
        (p, self._has_multi_parameters) = self._process_colparams(v)
        if self._has_multi_parameters:
            raise exc.ArgumentError("Can't    mix    single-values    and    multiple    values    formats    in    one    statement")
        self.parameters.update(p)
    if kwargs:
        if self._has_multi_parameters:
            raise exc.ArgumentError("Can't    pass    kwargs    and    multiple    parameter    sets    simultaenously")
        else:
            self.parameters.update(kwargs)
