Vous êtes un professionnel et vous avez besoin d'une formation ? Coder avec une
Intelligence Artificielle Voir le programme détaillé

Classe « TextClause »

Méthode sqlalchemy.TextClause.bindparams

Signature de la méthode bindparams

def bindparams(self, *binds: 'BindParameter[Any]', **names_to_values: 'Any') -> 'Self' 

Description

help(TextClause.bindparams)

Establish the values and/or types of bound parameters within
this :class:`_expression.TextClause` construct.

Given a text construct such as::

    from sqlalchemy import text

    stmt = text(
        "SELECT id, name FROM user WHERE name=:name AND timestamp=:timestamp"
    )

the :meth:`_expression.TextClause.bindparams`
method can be used to establish
the initial value of ``:name`` and ``:timestamp``,
using simple keyword arguments::

    stmt = stmt.bindparams(
        name="jack", timestamp=datetime.datetime(2012, 10, 8, 15, 12, 5)
    )

Where above, new :class:`.BindParameter` objects
will be generated with the names ``name`` and ``timestamp``, and
values of ``jack`` and ``datetime.datetime(2012, 10, 8, 15, 12, 5)``,
respectively.  The types will be
inferred from the values given, in this case :class:`.String` and
:class:`.DateTime`.

When specific typing behavior is needed, the positional ``*binds``
argument can be used in which to specify :func:`.bindparam` constructs
directly.  These constructs must include at least the ``key``
argument, then an optional value and type::

    from sqlalchemy import bindparam

    stmt = stmt.bindparams(
        bindparam("name", value="jack", type_=String),
        bindparam("timestamp", type_=DateTime),
    )

Above, we specified the type of :class:`.DateTime` for the
``timestamp`` bind, and the type of :class:`.String` for the ``name``
bind.  In the case of ``name`` we also set the default value of
``"jack"``.

Additional bound parameters can be supplied at statement execution
time, e.g.::

    result = connection.execute(
        stmt, timestamp=datetime.datetime(2012, 10, 8, 15, 12, 5)
    )

The :meth:`_expression.TextClause.bindparams`
method can be called repeatedly,
where it will re-use existing :class:`.BindParameter` objects to add
new information.  For example, we can call
:meth:`_expression.TextClause.bindparams`
first with typing information, and a
second time with value information, and it will be combined::

    stmt = text(
        "SELECT id, name FROM user WHERE name=:name "
        "AND timestamp=:timestamp"
    )
    stmt = stmt.bindparams(
        bindparam("name", type_=String), bindparam("timestamp", type_=DateTime)
    )
    stmt = stmt.bindparams(
        name="jack", timestamp=datetime.datetime(2012, 10, 8, 15, 12, 5)
    )

The :meth:`_expression.TextClause.bindparams`
method also supports the concept of
**unique** bound parameters.  These are parameters that are
"uniquified" on name at statement compilation time, so that  multiple
:func:`_expression.text`
constructs may be combined together without the names
conflicting.  To use this feature, specify the
:paramref:`.BindParameter.unique` flag on each :func:`.bindparam`
object::

    stmt1 = text("select id from table where name=:name").bindparams(
        bindparam("name", value="name1", unique=True)
    )
    stmt2 = text("select id from table where name=:name").bindparams(
        bindparam("name", value="name2", unique=True)
    )

    union = union_all(stmt1.columns(column("id")), stmt2.columns(column("id")))

The above statement will render as:

.. sourcecode:: sql

    select id from table where name=:name_1
    UNION ALL select id from table where name=:name_2

.. versionadded:: 1.3.11  Added support for the
   :paramref:`.BindParameter.unique` flag to work with
   :func:`_expression.text`
   constructs.

Vous êtes un professionnel et vous avez besoin d'une formation ? Sensibilisation à
l'Intelligence Artificielle Voir le programme détaillé