connections are permanently set in autocommit mode. The SQLAlchemy connection
pool as well as the :class:`.Connection` will still seek to invoke the DBAPI
``.rollback()`` method upon connection :term:`release`, as their behavior
-remains agonstic of the isolation level that's configured on the connection.
+remains agnostic of the isolation level that's configured on the connection.
As this rollback still incurs a network round trip under most if not all
DBAPI drivers, this additional network trip may be disabled using the
:paramref:`.create_engine.skip_autocommit_rollback` parameter, which will
.. versionadded:: 1.4.40 Added
:paramref:`_engine.Connection.execution_options.yield_per`
as a Core level execution option to conveniently set streaming results,
- buffer size, and partition size all at once in a manner that is transferrable
+ buffer size, and partition size all at once in a manner that is transferable
to that of the ORM's similar use case.
.. _engine_stream_results_sr:
:paramref:`_sa.create_engine.pool_logging_name` parameters with
:func:`sqlalchemy.create_engine`; the name will be appended to existing
class-qualified logging name. This use is recommended for applications that
-make use of multiple global :class:`.Engine` instances simultaenously, so
+make use of multiple global :class:`.Engine` instances simultaneously, so
that they may be distinguished in logging::
>>> import logging
"user".id = address.user_id AND address.email LIKE :email_1 || '%%'
>>>
-Other arguments that are transferrable include the
+Other arguments that are transferable include the
:paramref:`_orm.relationship.secondary` parameter that refers to a
many-to-many association table, as well as the "join" arguments
:paramref:`_orm.relationship.primaryjoin` and
frequently be subsequent issues where autoflush would prematurely flush the
object and cause errors, in those cases where the given object was still being
constructed and wasn't in a ready state to be flushed. The option to select between
-uni-directional and bi-directional behvaiors was also removed, as this option
+uni-directional and bi-directional behaviors was also removed, as this option
created two slightly different ways of working, adding to the overall learning
curve of the ORM as well as to the documentation and user support burden.
.. tip::
When using :class:`_orm.MappedAsDataclass` without a declarative base in
- the hiearchy, the target class is still turned into a real Python dataclass,
+ the hierarchy, the target class is still turned into a real Python dataclass,
so that it may properly serve as a base for a mapped dataclass. Using
:class:`_orm.MappedAsDataclass` (or the :func:`_orm.unmapped_dataclass` decorator
described later in this section) is required in order for the class to be correctly
as an indicator for nullability of the :class:`_schema.Column`. When ``None`` is present in the
union either as it is placed in the :class:`_orm.Mapped` construct. When
present in :class:`_orm.Mapped`, it indicates the :class:`_schema.Column`
-would be nullable, in the absense of more specific indicators. This logic works
+would be nullable, in the absence of more specific indicators. This logic works
in the same way as indicating an ``Optional`` type as described at
:ref:`orm_declarative_mapped_column_nullability`.
When objects are added to an ORM :class:`.Session` using :meth:`.Session.add`,
the ORM :term:`flush` process takes on the task of reconciling object
-refereneces that correspond to :func:`_orm.relationship` configurations and
-delivering this state to the databse using INSERT/UPDATE/DELETE statements. In
+references that correspond to :func:`_orm.relationship` configurations and
+delivering this state to the database using INSERT/UPDATE/DELETE statements. In
this specific example, if we associate an ``Article`` with a particular
``Magazine``, but then associate the ``Article`` with a ``Writer`` that's
associated with a *different* ``Magazine``, this flush process will overwrite
FROM my_table WHERE my_table.id = %s
A future release of SQLAlchemy may seek to improve the efficiency of
-eager defaults in the abcense of RETURNING to batch many rows within a
+eager defaults in the absence of RETURNING to batch many rows within a
single SELECT statement.
Case 4: primary key, RETURNING or equivalent is supported
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
