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

Module « sqlalchemy »

Fonction column - module sqlalchemy

Signature de la fonction column

def column(text: 'str', type_: 'Optional[_TypeEngineArgument[_T]]' = None, is_literal: 'bool' = False, _selectable: 'Optional[FromClause]' = None) -> 'ColumnClause[_T]' 

Description

help(sqlalchemy.column)

Produce a :class:`.ColumnClause` object.

The :class:`.ColumnClause` is a lightweight analogue to the
:class:`_schema.Column` class.  The :func:`_expression.column`
function can
be invoked with just a name alone, as in::

    from sqlalchemy import column

    id, name = column("id"), column("name")
    stmt = select(id, name).select_from("user")

The above statement would produce SQL like:

.. sourcecode:: sql

    SELECT id, name FROM user

Once constructed, :func:`_expression.column`
may be used like any other SQL
expression element such as within :func:`_expression.select`
constructs::

    from sqlalchemy.sql import column

    id, name = column("id"), column("name")
    stmt = select(id, name).select_from("user")

The text handled by :func:`_expression.column`
is assumed to be handled
like the name of a database column; if the string contains mixed case,
special characters, or matches a known reserved word on the target
backend, the column expression will render using the quoting
behavior determined by the backend.  To produce a textual SQL
expression that is rendered exactly without any quoting,
use :func:`_expression.literal_column` instead,
or pass ``True`` as the
value of :paramref:`_expression.column.is_literal`.   Additionally,
full SQL
statements are best handled using the :func:`_expression.text`
construct.

:func:`_expression.column` can be used in a table-like
fashion by combining it with the :func:`.table` function
(which is the lightweight analogue to :class:`_schema.Table`
) to produce
a working table construct with minimal boilerplate::

    from sqlalchemy import table, column, select

    user = table(
        "user",
        column("id"),
        column("name"),
        column("description"),
    )

    stmt = select(user.c.description).where(user.c.name == "wendy")

A :func:`_expression.column` / :func:`.table`
construct like that illustrated
above can be created in an
ad-hoc fashion and is not associated with any
:class:`_schema.MetaData`, DDL, or events, unlike its
:class:`_schema.Table` counterpart.

:param text: the text of the element.

:param type: :class:`_types.TypeEngine` object which can associate
  this :class:`.ColumnClause` with a type.

:param is_literal: if True, the :class:`.ColumnClause` is assumed to
  be an exact expression that will be delivered to the output with no
  quoting rules applied regardless of case sensitive settings. the
  :func:`_expression.literal_column()` function essentially invokes
  :func:`_expression.column` while passing ``is_literal=True``.

.. seealso::

    :class:`_schema.Column`

    :func:`_expression.literal_column`

    :func:`.table`

    :func:`_expression.text`

    :ref:`tutorial_select_arbitrary_text`

Vous êtes un professionnel et vous avez besoin d'une formation ? RAG (Retrieval-Augmented Generation)
et Fine Tuning d'un LLM Voir le programme détaillé