Fixed bug in cache key generation for baked queries which could cause a
too-short cache key to be generated for the case of eager loads across
subclasses. This could in turn cause the eagerload query to be cached in
- place of a non-eagerload query, or vice versa, for a polymorhic "selectin"
+ place of a non-eagerload query, or vice versa, for a polymorphic "selectin"
load, or possibly for lazy loads or selectin loads as well.
.. change::
Fixed issue where an :class:`.Index` that is deferred in being associated
with a table, such as as when it contains a :class:`.Column` that is not
associated with any :class:`.Table` yet, would fail to attach correctly if
- it also contained a non table-oriented expession.
+ it also contained a non table-oriented expression.
.. change::
:tags: bug, mysql
:tickets: 5239
- Fixed issue in MySQL dialect when connecting to a psuedo-MySQL database
+ Fixed issue in MySQL dialect when connecting to a pseudo-MySQL database
such as that provided by ProxySQL, the up front check for isolation level
when it returns no row will not prevent the dialect from continuing to
connect. A warning is emitted that the isolation level could not be
:tickets: 5198
Added a new parameter :paramref:`_orm.query_expression.default_expr` to the
- :func:`_orm.query_expression` construct, which will be appled to queries
+ :func:`_orm.query_expression` construct, which will be applied to queries
automatically if the :func:`_orm.with_expression` option is not used. Pull
request courtesy Haoyu Sun.
\ No newline at end of file
Fixed an issue where the ``is_disconnect`` function in the SQL Server
pyodbc dialect was incorrectly reporting the disconnect state when the
- exception messsage had a substring that matched a SQL Server ODBC error
+ exception message had a substring that matched a SQL Server ODBC error
code.
\ No newline at end of file
Additional logic has been added such that certain SQL expressions which
typically wrap a single database column will use the name of that column as
their "anonymous label" name within a SELECT statement, potentially making
- key-based lookups in result tuples more intutive. The primary example of
+ key-based lookups in result tuples more intuitive. The primary example of
this is that of a CAST expression, e.g. ``CAST(table.colname AS INTEGER)``,
which will export its default name as "colname", rather than the usual
"anon_1" label, that is, ``CAST(table.colname AS INTEGER) AS colname``.
:class:`_expression.SelectBase` (which is what's produced by :func:`_expression.select`) or
:class:`_query.Query` object is passed directly to these functions and others,
the ORM is typically coercing them to be a subquery by calling the
- :meth:`_expression.SelectBase.alias` method automatically (which is now superceded by
+ :meth:`_expression.SelectBase.alias` method automatically (which is now superseded by
the :meth:`_expression.SelectBase.subquery` method). See the migration notes linked
below for further details.
All long-deprecated "extension" classes have been removed, including
MapperExtension, SessionExtension, PoolListener, ConnectionProxy,
- AttributExtension. These classes have been deprecated since version 0.7
+ AttributeExtension. These classes have been deprecated since version 0.7
long superseded by the event listener system.
:tags: change, mysql
:tickets: 4643
- Remove deprecated dialect ``mysql+gaerdbms`` that has beed deprecated
+ Remove deprecated dialect ``mysql+gaerdbms`` that has been deprecated
since version 1.0. Use the MySQLdb dialect directly.
Remove deprecated parameter ``quoting`` from :class:`.mysql.ENUM`
rather than throw a :class:`.FlushError`. The rationale is so that the
flush will proceed and raise a :class:`.IntegrityError` instead, in the
same way as if the existing object were not present in the identity map
- already. This helps with schemes that are uinsg the
+ already. This helps with schemes that are using the
:class:`.IntegrityError` as a means of catching whether or not a row
already exists in the table.
Added support for use of the :class:`.Sequence` construct with MariaDB 10.3
and greater, as this is now supported by this database. The construct
integrates with the :class:`_schema.Table` object in the same way that it does for
- other databases like PostrgreSQL and Oracle; if is present on the integer
+ other databases like PostgreSQL and Oracle; if is present on the integer
primary key "autoincrement" column, it is used to generate defaults. For
backwards compatibility, to support a :class:`_schema.Table` that has a
:class:`.Sequence` on it to support sequence only databases like Oracle,
:func:`_expression.select` construct such that when a select statement
is used in a subquery, repeated column names from different tables are now
automatically labeled with a unique label name, without the need to use the
- full "apply_labels()" feature that conbines tablename plus column name.
- The disambigated labels are available as plain string keys in the .c
+ full "apply_labels()" feature that combines tablename plus column name.
+ The disambiguated labels are available as plain string keys in the .c
collection of the subquery, and most importantly the feature allows an ORM
:func:`_orm.aliased` construct against the combination of an entity and an
arbitrary subquery to work correctly, targeting the correct columns despite
.. versionchanged:: 1.0.0 - The DDL system invoked by
:meth:`_schema.MetaData.create_all`
and :meth:`_schema.MetaData.drop_all` will now automatically resolve mutually
- depdendent foreign keys between tables declared by
+ dependent foreign keys between tables declared by
:class:`_schema.ForeignKeyConstraint` and :class:`_schema.ForeignKey` objects, without
the need to explicitly set the :paramref:`_schema.ForeignKeyConstraint.use_alter`
flag.
.. sourcecode:: python+sql
from sqlalchemy.schema import CreateTable
- with engine.connecT() as conn:
+ with engine.connect() as conn:
{sql} conn.execute(CreateTable(mytable))
CREATE TABLE mytable (
col1 INTEGER,
relational
relational algebra
- An algrebraic system developed by Edgar F. Codd that is used for
+ An algebraic system developed by Edgar F. Codd that is used for
modelling and querying the data stored in relational databases.
.. seealso::
An acronym for **Data Manipulation Language**. DML is the subset of
SQL that relational databases use to *modify* the data in tables. DML
typically refers to the three widely familiar statements of INSERT,
- UPDATE and DELETE, otherwise known as :term:`CRUD` (acronoym for "CReate,
+ UPDATE and DELETE, otherwise known as :term:`CRUD` (acronym for "CReate,
Update, Delete").
.. seealso::
In the above example, it is **not** as intuitive that the ``Address`` would
automatically be added to the :class:`.Session`. However, the backref behavior
of ``Address.user`` indicates that the ``Address`` object is also appended to
-the ``User.addresses`` collection. This in turn intiates a **cascade**
+the ``User.addresses`` collection. This in turn initiates a **cascade**
operation which indicates that this ``Address`` should be placed into the
:class:`.Session` as a :term:`pending` object.
class User(Base):
# ...
- addresses = relationship("Address", back_populates="user", cascade_backefs=False)
+ addresses = relationship("Address", back_populates="user", cascade_backrefs=False)
See the example in :ref:`backref_cascade` for further information.
WHERE employee.id IN (?) ORDER BY employee.id
(1,)
-Combining "selectin" polymorhic loading with query-time
+Combining "selectin" polymorphic loading with query-time
:func:`_orm.with_polymorphic` usage is also possible (though this is very
outer-space stuff!); assuming the above mappings had no ``polymorphic_load``
set up, we could get the same result as follows::
As far as the use case of a class that can actually be fully persisted
to different tables under different scenarios, very early versions of
SQLAlchemy offered a feature for this adapted from Hibernate, known
-as the "entity name" feature. However, this use case became infeasable
+as the "entity name" feature. However, this use case became infeasible
within SQLAlchemy once the mapped class itself became the source of SQL
expression construction; that is, the class' attributes themselves link
directly to mapped table columns. The feature was removed and replaced
we can pass additional arguments to :meth:`.Session.connection` in order to
affect how the bind is procured::
- sess = my_sesssionmaker()
+ sess = my_sessionmaker()
# set up a transaction for the bind associated with
# the User mapper
# for row in conn.exec_driver_sql(
# "select session_id from sys.dm_exec_sessions "
# "where database_id=db_id('%s')" % ident):
- # log.info("killing SQL server sesssion %s", row['session_id'])
+ # log.info("killing SQL server session %s", row['session_id'])
# conn.exec_driver_sql("kill %s" % row['session_id'])
conn.exec_driver_sql("drop database %s" % ident)
As is the case for all DBAPIs under Python 3, all strings are inherently
Unicode strings. Under Python 2, cx_Oracle also supports Python Unicode
-objects directly. In all cases however, the driver requires an explcit
+objects directly. In all cases however, the driver requires an explicit
encoding configuration.
Ensuring the Correct Client Encoding
"deactive", however leave this transaction object in place as far
as the connection's state.
- for a "real" transaction this should roll back the transction
+ for a "real" transaction this should roll back the transaction
and ensure this transaction is no longer a reset agent.
this is used for nesting of marker transactions where the marker
if result is not None:
if result[MD_OBJECTS] is _UNPICKLED:
util.warn_deprecated(
- "Retreiving row values using Column objects from a "
+ "Retrieving row values using Column objects from a "
"row that was unpickled is deprecated; adequate "
"state cannot be pickled for this to be efficient. "
"This usage will raise KeyError in a future release.",
)
else:
util.warn_deprecated(
- "Retreiving row values using Column objects with only "
+ "Retrieving row values using Column objects with only "
"matching names as keys is deprecated, and will raise "
"KeyError in a future release; only Column "
"objects that are explicitly part of the statement "
class NoCursorFetchStrategy(ResultFetchStrategy):
"""Cursor strategy for a result that has no open cursor.
- There are two varities of this strategy, one for DQL and one for
+ There are two varieties of this strategy, one for DQL and one for
DML (and also DDL), each of which represent a result that had a cursor
but no longer has one.
"""True if this dialect supports sane rowcount even if RETURNING is
in use.
- For dialects that don't support RETURNING, this is synomous
+ For dialects that don't support RETURNING, this is synonym
with supports_sane_rowcount.
"""
* ``autoincrement`` - indicates that the column is auto incremented -
this is returned as a boolean or 'auto'
- * ``comment`` - (optional) the commnet on the column. Only some
+ * ``comment`` - (optional) the comment on the column. Only some
dialects return this key
* ``computed`` - (optional) when present it indicates that this column
.. warning:: The ``once`` argument does not imply automatic de-registration
of the listener function after it has been invoked a first time; a
listener entry will remain associated with the target object.
- Associating an arbitrarily high number of listeners without explictitly
+ Associating an arbitrarily high number of listeners without explicitly
removing them will cause memory to grow unbounded even if ``once=True``
is specified.
.. warning:: The ``once`` argument does not imply automatic de-registration
of the listener function after it has been invoked a first time; a
listener entry will remain associated with the target object.
- Associating an arbitrarily high number of listeners without explictitly
+ Associating an arbitrarily high number of listeners without explicitly
removing them will cause memory to grow unbounded even if ``once=True``
is specified.
* :class:`_schema.DDL` and objects which inherit from
:class:`_schema.DDLElement`
- :param parameters: parameters which will be bound into the statment.
+ :param parameters: parameters which will be bound into the statement.
This may be either a dictionary of parameter names to values,
or a mutable sequence (e.g. a list) of dictionaries. When a
list of dictionaries is passed, the underlying statement execution
# they aren't calling "engine.begin()" explicitly, however, DDL
# may be a special case for which we want to continue doing it this
# way. A big win here is that the full DDL sequence is inside of a
- # single transaction rather than COMMIT for each statment.
+ # single transaction rather than COMMIT for each statement.
with self.begin() as conn:
conn._run_ddl_visitor(visitorcallable, element, **kwargs)
@_generative
def join(self, target, onclause=None, isouter=False, full=False):
- r"""Create a SQL JOIN against this :class:`_expresson.Select`
+ r"""Create a SQL JOIN against this :class:`_expression.Select`
object's criterion
and apply generatively, returning the newly resulting
:class:`_expression.Select`.
def join_from(
self, from_, target, onclause=None, isouter=False, full=False
):
- r"""Create a SQL JOIN against this :class:`_expresson.Select`
+ r"""Create a SQL JOIN against this :class:`_expression.Select`
object's criterion
and apply generatively, returning the newly resulting
:class:`_expression.Select`.
if self.order_by:
# the default coercion for ORDER BY is now the OrderByRole,
# which adds an additional post coercion to ByOfRole in that
- # elements are converted into label refernences. For the
+ # elements are converted into label references. For the
# eager load / subquery wrapping case, we need to un-coerce
# the original expressions outside of the label references
# in order to have them render.
"from, there are multiple FROMS which can "
"join to this entity. Please use the .select_from() "
"method to establish an explicit left side, as well as "
- "providing an explcit ON clause if not present already to "
+ "providing an explicit ON clause if not present already to "
"help resolve the ambiguity."
)
else:
"Don't know how to join to %r. "
"Please use the .select_from() "
"method to establish an explicit left side, as well as "
- "providing an explcit ON clause if not present already to "
+ "providing an explicit ON clause if not present already to "
"help resolve the ambiguity." % (right,)
)
"from, there are multiple FROMS which can "
"join to this entity. Please use the .select_from() "
"method to establish an explicit left side, as well as "
- "providing an explcit ON clause if not present already to "
+ "providing an explicit ON clause if not present already to "
"help resolve the ambiguity."
)
else:
"Don't know how to join to %r. "
"Please use the .select_from() "
"method to establish an explicit left side, as well as "
- "providing an explcit ON clause if not present already to "
+ "providing an explicit ON clause if not present already to "
"help resolve the ambiguity." % (right,)
)
else:
column = column._deannotate()
# use entity_zero as the from if we have it. this is necessary
- # for polymorpic scenarios where our FROM is based on ORM entity,
+ # for polymorphic scenarios where our FROM is based on ORM entity,
# not the FROM of the column. but also, don't use it if our column
# doesn't actually have any FROMs that line up, such as when its
# a scalar subquery.
# this is a hack right now. The Query only knows how to
# make subsequent joins() without a given left-hand side
# from self._from_obj[0]. We need to ensure prop.secondary
- # is in the FROM. So we purposly put the mapper selectable
+ # is in the FROM. So we purposely put the mapper selectable
# in _from_obj[0] to ensure a user-defined join() later on
# doesn't fail, and secondary is then in _from_obj[1].
self._from_obj = (prop.mapper.selectable, prop.secondary)
setattr(self.class_, self.MANAGER_ATTR, self)
def dispose(self):
- """Dissasociate this manager from its class."""
+ """Disassociate this manager from its class."""
delattr(self.class_, self.MANAGER_ATTR)
# this attribute is replaced by sqlalchemy.ext.instrumentation
-# when importred.
+# when imported.
_instrumentation_factory = InstrumentationFactory()
# these attributes are replaced by sqlalchemy.ext.instrumentation
cached_populators,
)
else:
- # loader strategries like subqueryload, selectinload,
+ # loader strategies like subqueryload, selectinload,
# joinedload, basically relationships, these need to interact
# with the context each time to work correctly.
todo.append(prop)
# concrete inheritance, the class manager might have some keys
# of attributes on the superclass that we didn't actually map.
# These could be mapped as "concrete, dont load" or could be completely
- # exluded from the mapping and we know nothing about them. Filter them
+ # excluded from the mapping and we know nothing about them. Filter them
# here to prevent them from coming through.
if attribute_names:
attribute_names = attribute_names.intersection(mapper.attrs.keys())
that specify ``delete-orphan`` cascade. This behavior is more
consistent with that of a persistent object, and allows behavior to
be consistent in more scenarios independently of whether or not an
- orphanable object has been flushed yet or not.
+ orphan object has been flushed yet or not.
See the change note and example at :ref:`legacy_is_orphan_addition`
for more detail on this change.
def is_orm_statement(self):
"""return True if the operation is an ORM statement.
- This indictes that the select(), update(), or delete() being
+ This indicates that the select(), update(), or delete() being
invoked contains ORM entities as subjects. For a statement
that does not have ORM entities and instead refers only to
:class:`.Table` metadata, it is invoked as a Core SQL statement
eq_(result.all(), [])
def test_one_unique(self):
- # assert that one() counts rows after uniquness has been applied.
+ # assert that one() counts rows after uniqueness has been applied.
# this would raise if we didnt have unique
result = self._fixture(data=[(1, 1, 1), (1, 1, 1)])
assert_raises(exc.MultipleResultsFound, result.unique().one)
def test_one_unique_mapping(self):
- # assert that one() counts rows after uniquness has been applied.
+ # assert that one() counts rows after uniqueness has been applied.
# this would raise if we didnt have unique
result = self._fixture(data=[(1, 1, 1), (1, 1, 1)])
"""
The underlying reflect call accepts an optional schema argument.
This is for determining which database schema to load.
- This test verifies that prepare can accept an optiona schema argument
- and pass it to reflect.
+ This test verifies that prepare can accept an optional schema
+ argument and pass it to reflect.
"""
Base = automap_base(metadata=self.metadata)
engine_mock = Mock()
"""Exercises for eager loading.
-Derived from mailing list-reported problems and trac tickets.
+Derived from mailing list-reported problems and track tickets.
These are generally very old 0.1-era tests and at some point should
be cleaned up and modernized.
),
(
lambda User: future_select(1).where(User.name == "ed"),
- # no mapper for this one becuase the plugin is not "orm"
+ # no mapper for this one because the plugin is not "orm"
lambda User: {"clause": mock.ANY},
"e1",
),
def go():
with testing.expect_deprecated(
r"Using the Query.instances\(\) method without a context",
- "Retreiving row values using Column objects with only "
+ "Retrieving row values using Column objects with only "
"matching names",
):
result = list(
r"Using the Query.instances\(\) method without a context",
r"Passing a string name for the 'alias' argument to "
r"'contains_eager\(\)` is deprecated",
- "Retreiving row values using Column objects with only "
+ "Retrieving row values using Column objects with only "
"matching names",
):
result = list(
r"Using the Query.instances\(\) method without a context",
r"Passing a string name for the 'alias' argument to "
r"'contains_eager\(\)` is deprecated",
- "Retreiving row values using Column objects with only "
+ "Retrieving row values using Column objects with only "
"matching names",
):
result = list(
dont_compare_values_fixtures = [
lambda: (
- # note the in_(...) all have different column names becuase
+ # note the in_(...) all have different column names because
# otherwise all IN expressions would compare as equivalent
column("x").in_(random_choices(range(10), k=3)),
column("y").in_(
not_in_(bar.c.content_type, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(sql.column("content_type"), row)
not_in_(content.c.type, row)
not_in_(bar.c.content_type, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(sql.column("content_type"), row)
row = connection.execute(stmt).first()
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(keyed2.c.a, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(keyed2.c.b, row)
row = connection.execute(stmt).first()
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(a, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(b, row)
row = connection.execute(stmt).first()
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(keyed2.c.a, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(keyed2.c.b, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(a, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(b, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names",
"The SelectBase.c and SelectBase.columns",
):
in_(stmt.c.a, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names",
"The SelectBase.c and SelectBase.columns",
):
row = connection.execute(stmt).first()
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(keyed2.c.a, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(keyed2.c.b, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names",
"The SelectBase.c and SelectBase.columns",
):
in_(stmt.c.keyed2_a, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names",
"The SelectBase.c and SelectBase.columns",
):
row = connection.execute(stmt).first()
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(keyed2.c.a, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(keyed2.c.b, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names",
"The SelectBase.c and SelectBase.columns",
):
in_(stmt.c.keyed2_a, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names",
"The SelectBase.c and SelectBase.columns",
):
users = self.tables.users
with testing.expect_deprecated(
- # "Retreiving row values using Column objects "
+ # "Retrieving row values using Column objects "
# "with only matching names",
# "Using non-integer/slice indices on Row is "
# "deprecated and will be removed in version 2.0",
r._keymap.pop(users.c.user_id) # reset lookup
with testing.expect_deprecated(
- # "Retreiving row values using Column objects "
+ # "Retrieving row values using Column objects "
# "with only matching names"
):
eq_(r._mapping[users.c.user_id], 2)
with testing.expect_deprecated(
- # "Retreiving row values using Column objects "
+ # "Retrieving row values using Column objects "
# "with only matching names"
):
eq_(r._mapping[users.c.user_name], "jack")
with testing.expect_deprecated(
"Using non-integer/slice indices on Row is deprecated "
"and will be removed in version 2.0",
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names",
):
r = connection.execute(
r._keymap.pop(users.c.user_id)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
eq_(r._mapping[users.c.user_id], 2)
with testing.expect_deprecated(
"Using non-integer/slice indices on Row is deprecated "
"and will be removed in version 2.0",
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names",
):
eq_(r[users.c.user_name], "jack")
r._keymap.pop(users.c.user_name)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
eq_(r._mapping[users.c.user_name], "jack")
in_(content.c.type, row._mapping)
not_in_(bar.c.content_type, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(sql.column("content_type"), row)
select([content.c.type.label("content_type")])
).first()
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(content.c.type, row)
not_in_(bar.c.content_type, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(sql.column("content_type"), row)
not_in_(bar.c.content_type, row)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
in_(sql.column("content_type"), row)
if pickle:
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"from a row that was unpickled"
):
eq_(result[0]._mapping[users.c.user_id], 7)
result[0]._keymap.pop(users.c.user_id)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"from a row that was unpickled"
):
eq_(result[0]._mapping[users.c.user_id], 7)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"from a row that was unpickled"
):
eq_(result[0]._mapping[users.c.user_name], "jack")
result[0]._keymap.pop(users.c.user_name)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"from a row that was unpickled"
):
eq_(result[0]._mapping[users.c.user_name], "jack")
# causing 'user_id' to match when use_labels wasn't
# used.
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"from a row that was unpickled"
):
eq_(result[0]._mapping[addresses.c.user_id], 7)
result[0]._keymap.pop(addresses.c.user_id)
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"from a row that was unpickled"
):
eq_(result[0]._mapping[addresses.c.user_id], 7)
row = result.first()
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
eq_(row._mapping[text1.c.a], "a1")
# key fallback rules still match this to a column
# unambiguously based on its name
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
eq_(row._mapping[text1.c.a], "a1")
# key fallback rules still match this to a column
# unambiguously based on its name
with testing.expect_deprecated(
- "Retreiving row values using Column objects "
+ "Retrieving row values using Column objects "
"with only matching names"
):
eq_(row._mapping[text1.c.d], "d1")
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
