:paramref:`.FunctionElement.table_valued.joins_implicitly`, for the
:meth:`.FunctionElement.table_valued` construct. This parameter indicates
that the given table-valued function implicitly joins to the table it
- refers towards, essentially disabling the "from linting" feature, i.e. the
+ refers to, essentially disabling the "from linting" feature, i.e. the
"cartesian product" warning, from taking effect due to the presence of this
parameter. May be used for functions such as ``func.json_each()``.
:func:`_orm.relationship` that automap will be generating would emit the
"overlaps" warnings introduced in 1.4 and discussed at :ref:`error_qzyx`.
While generating this case from automap is still subject to the same
- caveats that the "overlaps" warning refers towards, as automap is intended
+ caveats that the "overlaps" warning refers to, as automap is intended
for more ad-hoc use cases, the condition which produces the warning is
disabled when a many-to-many relationship with this particular pattern is
generated.
parent mapped class it is associated with. While the
:class:`.AssociationProxy` historically began as a relatively simple "getter",
it became apparent early on that it also needed to make decisions about what
-kind of attribute it is referring towards, e.g. scalar or collection, mapped
+kind of attribute it is referring to, e.g. scalar or collection, mapped
object or simple value, and similar. To achieve this, it needs to inspect the
-mapped attribute or other descriptor or attribute that it refers towards, as
+mapped attribute or other descriptor or attribute that it refers to, as
referenced from its parent class. However in Python descriptor mechanics, a
descriptor only learns about its "parent" class when it is accessed in the
context of that class, such as calling ``MyClass.some_descriptor``, which calls
``Employee`` entity in the query. It then joins to a right-nested join of
``employee AS employee_1 JOIN manager AS manager_1``, where the ``employee``
table is stated again, except as an anonymous alias ``employee_1``. This is the
-"automatic generation of an alias" that the warning message refers towards.
+"automatic generation of an alias" that the warning message refers to.
When SQLAlchemy loads ORM rows that each contain an ``Employee`` and a
``Manager`` object, the ORM must adapt rows from what above is the
which is an internal process that occurs typically after all mappings have
been defined and is normally triggered by the first usage of the mappings
themselves. The :class:`_orm.registry` object is the container in which
-these names are stored and resolved to the mapped classes they refer towards.
+these names are stored and resolved to the mapped classes they refer to.
In addition to the main class argument for :func:`_orm.relationship`,
other arguments which depend upon the columns present on an as-yet
particular ``Magazine``, but then associate the ``Article`` with a
``Writer`` that's associated with a *different* ``Magazine``, the ORM
will overwrite ``Article.magazine_id`` non-deterministically, silently
-changing which magazine we refer towards; it may
+changing which magazine we refer to; it may
also attempt to place NULL into this column if we de-associate a
``Writer`` from an ``Article``. The warning lets us know this is the case.
>>> class Base(DeclarativeBase):
... pass
-Above, the ``Base`` class is what we'll refer towards as the Declarative Base.
+Above, the ``Base`` class is what we'll refer to as the Declarative Base.
When we make new classes that are subclasses of ``Base``, combined with
appropriate class-level directives, they will each be established as a new
**ORM mapped class** at class creation time, each one typically (but not
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
PostgreSQL supports passing a table as an argument to a function, which it
-refers towards as a "record" type. SQLAlchemy :class:`_sql.FromClause` objects
+refers to as a "record" type. SQLAlchemy :class:`_sql.FromClause` objects
such as :class:`_schema.Table` support this special form using the
:meth:`_sql.FromClause.table_valued` method, which is comparable to the
:meth:`_functions.FunctionElement.table_valued` method except that the collection
"""index name"""
column_names: List[Optional[str]]
- """column names which the index refers towards.
+ """column names which the index refers to.
An element of this list is ``None`` if it's an expression and is
returned in the ``expressions`` list.
"""
local_table: FromClause
"""The immediate :class:`_expression.FromClause` which this
- :class:`_orm.Mapper` refers towards.
+ :class:`_orm.Mapper` refers to.
Typically is an instance of :class:`_schema.Table`, may be any
:class:`.FromClause`.
element: ColumnElement[_T]
"""The underlying expression object to which this :class:`.Over`
- object refers towards."""
+ object refers to."""
range_: Optional[typing_Tuple[int, int]]
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
