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

Expires all persistent instances within this Session. When any attributes on a persistent instance is next accessed, a query will be

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

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

Apply a mappings filter to returned rows, returning an instance of :class:`_engine.MappingResult`. When this filter is applied, fetch

Close this Session, using connection invalidation. This is a variant of :meth:`.Session.close` that will additionally ensure that the

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

Configure all as-yet unconfigured mappers in this :class:`_orm.registry`. The configure step is used to reconcile and initialize the

r"""Construct :class:`_expression.Delete` object. E.g.:: from sqlalchemy import delete stmt = delete(user_table).where(user_tab

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

Denote an attribute name as a synonym to a mapped property, in that the attribute will mirror the value and expression behavior of another att

Remove all mappers from all classes. .. versionchanged:: 1.4 This function now locates all :class:`_orm.registry` objects and calls upon

r"""Implement the 'endswith' operator. Produces a LIKE expression that tests against a match for the end of a string value:

Append a :class:`_schema.Column` to this :class:`_schema.Table`. The "key" of the newly added :class:`_schema.Column`, i.e. the value

Construct a new bakery. :return: an instance of :class:`.Bakery`

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

Add additional WHERE criteria to the load for all occurrences of a particular entity. .. versionadded:: 1.4 The :func:`_orm.with_loader_

utility method used for unit tests only.

Clear all Table objects from this MetaData.

Return a dialect-specific implementation for this :class:`.TypeEngine`.

r"""Produce a ``CASE`` expression. The ``CASE`` construct in SQL is a conditional object that acts somewhat analogously to an "if/then" const

Assert a in b, with repr messaging on failure.

Conditionally quote an identifier. The identifier is quoted if it is a reserved word, contains quote-necessary characters, or is an i

legacy adapter function for functions that were previously using assert_raises with SAWarning or similar. has some workarounds to accommodate

Build DB-API compatible connection arguments. Given a :class:`.URL` object, returns a tuple consisting of a ``(*args, **kwargs)`` sui

Issue a ``DROP`` statement for this :class:`_schema.Table`, using the given :class:`.Connection` or :class:`.Engine` for connectivity.

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

Return a :class:`.Tuple`. Main usage is to produce a composite IN construct using :meth:`.ColumnOperators.in_` :: from sqlalchemy im

Produce a UNION of this Query against one or more queries. e.g.:: q1 = sess.query(SomeClass).filter(SomeClass.foo == "bar")

Produce a UNION ALL of this Query against one or more queries. Works the same way as :meth:`~sqlalchemy.orm.query.Query.union`. See t

r"""Produce a copy of this type object that will utilize the given type when applied to the dialect of the given name. e.g.::

return Range form of the same range

Produce a :func:`_expression.between` clause against the parent object, given the lower and upper range.

Prepare a quoted table and schema name.

Return a context that optimizes for multiple operations on a single transaction. This essentially allows connect()/close() to be call

return a MapperProperty associated with the given key.

r"""Add one or more :class:`_sql.CTE` constructs to this statement. This method will associate the given :class:`_sql.CTE` constructs with

r"""Return a new selectable with the given FETCH FIRST criterion applied. This is a numeric value which usually renders as ``FETCH {F

Return a collection of added + unchanged + deleted.

r"""Return a :class:`_sql.TableValuedAlias` representation of this :class:`_functions.FunctionElement` with table-valued expressions added.

update the :paramref:`_orm.registry.type_annotation_map` with new values.

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

r"""Construct a :class:`_expression.Values` construct representing the SQL ``VALUES`` clause. The column expressions and the actual data for

Add a column to this :class:`_sql.ColumnCollection`. .. note:: This method is **not normally used by user-facing code**, as the

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

Add an individual MapperProperty to this mapper. If the mapper has not been configured yet, just adds the property to the initial pro

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

Indicate that the given attribute should be loaded using subquery eager loading. This function is part of the :class:`_orm.Load` inte

Dictionary update() is not implemented for :class:`_sql.ColumnCollection`.

Produce a descending ``ORDER BY`` clause element. e.g.:: from sqlalchemy import desc stmt = select(users_table).order_by(desc(u

Construct a sqlite-specific variant :class:`_sqlite.Insert` construct. .. container:: inherited_member The :func:`sqlalchemy.dialect

Create a ``UNION`` statement used by a polymorphic mapper. See :ref:`concrete_inheritance` for an example of how this is used. :param t

Subclasses should call this method whenever change events occur.

Return information about foreign_keys in ``table_name``. Given a :class:`_engine.Connection`, a string ``table_name``, and an optiona

For internal dialect use, check the existence of a particular table or view in the database. Given a :class:`_engine.Connection` obje