r"""Implement the ``startswith`` operator. Produces a LIKE expression that tests against a match for the start of a string value:

return a new :class:`_query.Query` with the specified options for the ``FOR UPDATE`` clause. The behavior of this method is i

Context manager which expects one or more warnings. With no arguments, squelches all SAWarning emitted via sqlalchemy.util.warn and sqlalchem

Apply an ``OFFSET`` to the query and return the newly resulting ``Query``. .. seealso:: :meth:`_sql.Select.offset` - v2

Return the mapped object represented by this :class:`.InstanceState`. Returns None if the object has been garbage collected

Return the target :class:`_schema.Column` referenced by this :class:`_schema.ForeignKey`. If no target column has been established, a

Copy the state of a given instance into a corresponding instance within this :class:`.Session`. :meth:`.Session.merge` examines the p

Apply one or more GROUP BY criterion to the query and return the newly resulting :class:`_query.Query`. All existing GROUP BY setting

Receive a collection append event. The append event is invoked for each element as it is appended to the collection. This occurs for

Return ``True`` if this :class:`_engine.Result` was **hard closed** by explicitly calling the :meth:`close` method. The attribute is

r"""Provide a column-level property for use with a mapping. With Declarative mappings, :func:`_orm.column_property` is used to map read-only

r"""Construct a base class for declarative class definitions. The new base class will be given a metaclass that produces appropriate :class:`

Apply unique filtering to the objects returned by this :class:`_engine.Result`. When this filter is applied with no arguments, the ro

r"""Implement the ``like`` operator. In a column context, produces the expression: .. sourcecode:: sql a LIKE other

Initialize the inter-mapper relationships of all mappers that have been constructed thus far across all :class:`_orm.registry` collections.

r"""Indicate a column-based mapped attribute that by default will not load unless accessed. When using :func:`_orm.mapped_column`, the same f

Return a constant :class:`.True_` construct. E.g.: .. sourcecode:: pycon+sql >>> from sqlalchemy import true >>> print(sele

Begin a "nested" transaction on this Session, e.g. SAVEPOINT. The target database(s) and associated drivers must support SQL SAVEPOIN

r"""Create a SQL JOIN against this :class:`_expression.Select` object's criterion and apply generatively, returning the newly resultin

Return True if this :class:`_orm.Session` has begun a transaction. .. versionadded:: 1.4 .. seealso:: :attr:`_orm.Sessi

Return the first element of the first result or None if no rows present. If multiple rows are returned, raises :class:`_exc.MultipleR

Runs a sync function ``fn`` in a new greenlet. The sync function can then use :func:`await_` to wait for async functions. :param fn: The

Construct a PostgreSQL-specific variant :class:`_postgresql.Insert` construct. .. container:: inherited_member The :func:`sqlalchemy

Produce a conjunction of expressions joined by ``OR``. E.g.:: from sqlalchemy import or_ stmt = select(users_table).where(

r""" Specifies a DO UPDATE SET action for ON CONFLICT clause. :param index_elements: A sequence consisting of string column

Produce an OVER clause against this filtered function. Used against aggregate or so-called "window" functions, for database backends

Execute the given SELECT statement and return results. This method bypasses all internal statement compilation, and the statement is

Assert a != b, with repr messaging on failure.

Assert a is not b, with repr messaging on failure.

Assert a in b, with repr messaging on failure.

Return a :class:`.Query` construct which will correlate the given FROM clauses to that of an enclosing :class:`.Query` or :func:`~.exp

Produce a generic operator function. e.g.:: somecolumn.op("*")(5) produces:: somecolumn * 5 This func

r"""Return a Python property implementing a view of a target attribute which references an attribute on members of the target. The return

When using the :paramref:`_orm.relationship.backref` parameter, provides specific parameters to be used when the new :func:`_orm.relationship`

Awaits an async function in a sync method. The sync method must be inside a :func:`greenlet_spawn` context. :func:`await_` calls cannot be ne

Given a class, return the primary :class:`_orm.Mapper` associated with the key. Raises :exc:`.UnmappedClassError` if no mapping is configured

Flush all the object changes to the database. Writes out all pending object creations, deletions and modifications to the database as

given cursor.lastrowid value and the parameters used for INSERT, return a "row" that represents the primary key, either by usi

r"""Produce a ``CAST`` expression. :func:`.cast` returns an instance of :class:`.Cast`. E.g.:: from sqlalchemy import cast, Numeric

Retrieve an object based on identity. Equivalent to :meth:`_query.Query.get`.

Return an iterator yielding result tuples corresponding to the given list of columns

target dialect supports representation of Python datetime.datetime() objects.

Drop all tables stored in this metadata. Conditional by default, will not attempt to drop tables not present in the target database.

Return information about columns in ``table_name``. Given a :class:`_engine.Connection`, a string ``table_name``, and an optional str

Append a :class:`_schema.Constraint` to this :class:`_schema.Table`. This has the effect of the constraint being included in any

Dispose of this pool. This method leaves the possibility of checked-out connections remaining open, as it only affects connections th

Normalize sequence parameters for dialect that don't start with 1 by default. The default implementation does nothing

Make use of a :term:`RETURNING` clause for the purpose of fetching server-side expressions and defaults, for supporting backends only.

Return a context manager delivering a :class:`_engine.Connection` with a :class:`.Transaction` established. E.g.:: with

Assert a in not b, with repr messaging on failure.

Return a view of key/value tuples for the elements in the underlying :class:`.Row`.

r"""Produce an inner join between left and right clauses. :func:`_orm.join` is an extension to the core join interface provided by :func:`_ex

Return a constant :class:`.Null` construct.

Return True if this Column references the given column via foreign key.