performance implications (default changed from ``True`` in
0.7.0).
- .. note:: This functionality is now superceded by the
+ .. note:: This functionality is now superseded by the
``sqlalchemy.ext.mutable`` extension described in
:ref:`mutable_toplevel`.
raise NotImplementedError()
def handle_dbapi_exception(self, e):
- """Receive a DBAPI exception which occured upon execute, result
+ """Receive a DBAPI exception which occurred upon execute, result
fetch, etc."""
raise NotImplementedError()
class IdentifierError(SQLAlchemyError):
"""Raised when a schema name is beyond the max character limit"""
-# Moved to orm.exc; compatability definition installed by orm import until 0.6
+# Moved to orm.exc; compatibility definition installed by orm import until 0.6
ConcurrentModificationError = None
class DisconnectionError(SQLAlchemyError):
"""
-# Moved to orm.exc; compatability definition installed by orm import until 0.6
+# Moved to orm.exc; compatibility definition installed by orm import until 0.6
FlushError = None
class TimeoutError(SQLAlchemyError):
"""SQL was attempted without a database connection to execute it on."""
-# Moved to orm.exc; compatability definition installed by orm import until 0.6
+# Moved to orm.exc; compatibility definition installed by orm import until 0.6
UnmappedColumnError = None
class StatementError(SQLAlchemyError):
- """An error occured during execution of a SQL statement.
+ """An error occurred during execution of a SQL statement.
:class:`.StatementError` wraps the exception raised
during execution, and features :attr:`.statement`
is given, and that only columns which are declared specifically with that
type instance receive additional instrumentation.
- To associate a particular mutable type with all occurences of a
+ To associate a particular mutable type with all occurrences of a
particular type, use the :meth:`.Mutable.associate_with` classmethod
of the particular :meth:`.Mutable` subclass to establish a global
assoiation.
"""Interfaces and abstract types.
-This module is **deprecated** and is superceded by the
+This module is **deprecated** and is superseded by the
event system.
"""
comparator_factory=None, doc=None):
"""Denote an attribute name as a synonym to a mapped property.
- .. note:: :func:`.synonym` is superceded as of 0.7 by
+ .. note:: :func:`.synonym` is superseded as of 0.7 by
the :mod:`~sqlalchemy.ext.hybrid` extension. See
the documentation for hybrids at :ref:`hybrids_toplevel`.
"""Provides a method of applying a :class:`.PropComparator`
to any Python descriptor attribute.
- .. note:: :func:`.comparable_property` is superceded as of 0.7 by
+ .. note:: :func:`.comparable_property` is superseded as of 0.7 by
the :mod:`~sqlalchemy.ext.hybrid` extension. See the example
at :ref:`hybrid_custom_comparators`.
class History(tuple):
"""A 3-tuple of added, unchanged and deleted values,
- representing the changes which have occured on an instrumented
+ representing the changes which have occurred on an instrumented
attribute.
Each tuple member is an iterable sequence.
"""establish actions and dependencies related to a flush.
These actions will operate on all relevant states in
- the aggreagte.
+ the aggregate.
"""
uow.register_preprocessor(self, True)
transaction is ongoing."""
def after_commit(self, session):
- """Execute after a commit has occured.
+ """Execute after a commit has occurred.
Note that this may not be per-flush if a longer running
transaction is ongoing."""
def after_rollback(self, session):
- """Execute after a rollback has occured.
+ """Execute after a rollback has occurred.
Note that this may not be per-flush if a longer running
transaction is ongoing."""
This will be when the 'new', 'dirty', and 'deleted' lists are in
their final state. An actual commit() may or may not have
- occured, depending on whether or not the flush started its own
+ occurred, depending on whether or not the flush started its own
transaction or participated in a larger transaction. """
def after_begin( self, session, transaction, connection):
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
-"""Descriptor proprerties are more "auxilliary" properties
+"""Descriptor properties are more "auxiliary" properties
that exist as configurational elements, but don't participate
as actively in the load/persist ORM loop.
not issubclass(target.session_factory, Session):
raise exc.ArgumentError(
"Session event listen on a ScopedSession "
- "requries that its creation callable "
+ "requires that its creation callable "
"is a Session subclass.")
return target.session_factory
elif isinstance(target, type):
transaction is ongoing."""
def after_commit(self, session):
- """Execute after a commit has occured.
+ """Execute after a commit has occurred.
Note that this may not be per-flush if a longer running
transaction is ongoing."""
def after_rollback(self, session):
- """Execute after a rollback has occured.
+ """Execute after a rollback has occurred.
Note that this may not be per-flush if a longer running
transaction is ongoing."""
This will be when the 'new', 'dirty', and 'deleted' lists are in
their final state. An actual commit() may or may not have
- occured, depending on whether or not the flush started its own
+ occurred, depending on whether or not the flush started its own
transaction or participated in a larger transaction. """
def after_begin( self, session, transaction, connection):
This is used to allow more open ended selection of loader strategies, i.e.
Mapper -> prop1 -> Subclass -> prop2, where Subclass is a sub-mapper
- of the mapper referened by Mapper.prop1.
+ of the mapper referenced by Mapper.prop1.
"""
return tuple([i % 2 != 0 and
self.configured = False
# prevent this mapper from being constructed
- # while a configure_mappers() is occuring (and defer a configure_mappers()
+ # while a configure_mappers() is occurring (and defer a configure_mappers()
# until construction succeeds)
_COMPILE_MUTEX.acquire()
try:
has_all_pks = False
elif col.default is None and \
col.server_default is None:
- params[col.key] = value
+ params[col.key] = value
elif isinstance(value, sql.ClauseElement):
value_params[col] = value
if inheriting is not self.parent \
and inheriting.has_property(self.key):
util.warn("Warning: relationship '%s' on mapper "
- "'%s' supercedes the same relationship "
+ "'%s' supersedes the same relationship "
"on inherited mapper '%s'; this can "
"cause dependency issues during flush"
% (self.key, self.parent, inheriting))
def _sync_pairs_from_join(self, join_condition, primary):
"""Given a join condition, figure out what columns are foreign
- and are part of a binary "equated" condition to their referecned
+ and are part of a binary "equated" condition to their referenced
columns, and convert into a list of tuples of (primary col->foreign col).
Make several attempts to determine if cols are compared using
# adjust the join condition for single table inheritance,
# in the case that the join is to a subclass
- # this is analgous to the "_adjust_for_single_table_inheritance()"
+ # this is analogous to the "_adjust_for_single_table_inheritance()"
# method in Query.
dest_mapper = of_type or self.mapper
@property
def _mapper_entities(self):
- # TODO: this is wrong, its hardcoded to "priamry entity" when
+ # TODO: this is wrong, its hardcoded to "primary entity" when
# for the case of __all_equivs() it should not be
# the name of this accessor is wrong too
for ent in self._entities:
"""Return the full SELECT statement represented by this :class:`.Query`, converted
to a scalar subquery with a label of the given name.
- Analagous to :meth:`sqlalchemy.sql._SelectBaseMixin.label`.
+ Analogous to :meth:`sqlalchemy.sql._SelectBaseMixin.label`.
New in 0.6.5.
"""Return the full SELECT statement represented by this :class:`.Query`, converted
to a scalar subquery.
- Analagous to :meth:`sqlalchemy.sql._SelectBaseMixin.as_scalar`.
+ Analogous to :meth:`sqlalchemy.sql._SelectBaseMixin.as_scalar`.
New in 0.6.5.
self._setup_aliasizers(self._entities[l:])
@util.pending_deprecation("0.7",
- ":meth:`.add_column` is superceded by :meth:`.add_columns`",
+ ":meth:`.add_column` is superseded by :meth:`.add_columns`",
False)
def add_column(self, column):
"""Add a column expression to the list of result columns to be returned.
- Pending deprecation: :meth:`.add_column` will be superceded by
+ Pending deprecation: :meth:`.add_column` will be superseded by
:meth:`.add_columns`.
"""
A two-element form of \*props may also be passed. In this form,
the first element is a target class or selectable, the second
is a string property name, class-mapped attribute, or clause
- construct representing an "ON" clause. This supercedes the
+ construct representing an "ON" clause. This supersedes the
previous "tuple" calling form - multiple join() calls should
be used for multiple (target, onclause) pairs.
def outerjoin(self, *props, **kwargs):
"""Create a left outer join against this ``Query`` object's criterion
- and apply generatively, retunring the newly resulting ``Query``.
+ and apply generatively, returning the newly resulting ``Query``.
Usage is the same as the ``join()`` method.
# look for ORM entities represented within the
# given expression. Try to count only entities
- # for columns whos FROM object is in the actual list
+ # for columns whose FROM object is in the actual list
# of FROMs for the overall expression - this helps
# subqueries which were built from ORM constructs from
# leaking out their entities into the main select construct
:param close_with_result: Passed to :meth:`Engine.connect`, indicating
the :class:`.Connection` should be considered "single use", automatically
closing when the first result set is closed. This flag only has
- an effect if this :class:`.Session` is configued with ``autocommit=True``
+ an effect if this :class:`.Session` is configured with ``autocommit=True``
and does not already have a transaction in progress.
:param \**kw:
def expire_all(self):
"""Expires all persistent instances within this Session.
- When any attributes on a persitent instance is next accessed,
+ When any attributes on a persistent instance is next accessed,
a query will be issued using the
:class:`.Session` object's current transactional context in order to
load all expired attributes for the given instance. Note that
not mapper.allow_partial_pks or \
_none_set.issuperset(instance_key[1]):
raise exc.FlushError('Instance %s has a NULL identity '
- 'key. Check if this flush is occuring at an '
+ 'key. Check if this flush is occurring at an '
'inappropriate time, such as during a load '
'operation.' % mapperutil.state_str(state))
except exc.UnmappedColumnError:
_raise_col_to_prop(True, source_mapper, l, dest_mapper, r)
- # techically the "r.primary_key" check isn't
+ # technically the "r.primary_key" check isn't
# needed here, but we check for this condition to limit
# how often this logic is invoked for memory/performance
# reasons, since we only need this info for a primary key
:class:`~sqlalchemy.interfaces.PoolListener`-like objects or
dictionaries of callables that receive events when DB-API
connections are created, checked out and checked in to the
- pool. This has been superceded by
+ pool. This has been superseded by
:func:`~sqlalchemy.event.listen`.
"""
will be called at statement execution time to determine the
ultimate value. Used for scenarios where the actual bind
value cannot be determined at the point at which the clause
- construct is created, but embeded bind values are still desirable.
+ construct is created, but embedded bind values are still desirable.
:param type\_:
A ``TypeEngine`` object that will be used to pre-process the
return fromclause in self._cloned_set
def replace_selectable(self, old, alias):
- """replace all occurences of FromClause 'old' with the given Alias
+ """replace all occurrences of FromClause 'old' with the given Alias
object, returning a copy of this :class:`FromClause`.
"""
Note that the ORM makes use of its own "compiled" caches for
some operations, including flush operations. The caching
- used by the ORM internally supercedes a cache dictionary
+ used by the ORM internally supersedes a cache dictionary
specified here.
See also:
# detect immutable, don't change anything
return self
else:
- # update the clone with any changes that have occured
+ # update the clone with any changes that have occurred
# to this object's __dict__.
clone.__dict__.update(self.__dict__)
return Annotated(clone, self._annotations)
are serialized into strings are examples of "mutable"
column structures.
- .. note:: This functionality is now superceded by the
+ .. note:: This functionality is now superseded by the
``sqlalchemy.ext.mutable`` extension described in
:ref:`mutable_toplevel`.
are serialized into strings are examples of "mutable"
column structures.
- .. note:: This functionality is now superceded by the
+ .. note:: This functionality is now superseded by the
``sqlalchemy.ext.mutable`` extension described in
:ref:`mutable_toplevel`.
a mutable Python object type. This functionality is used
only by the ORM.
- .. note:: :class:`.MutableType` is superceded as of SQLAlchemy 0.7
+ .. note:: :class:`.MutableType` is superseded as of SQLAlchemy 0.7
by the ``sqlalchemy.ext.mutable`` extension described in
:ref:`mutable_toplevel`. This extension provides an event
driven approach to in-place mutation detection that does not
behavior. (default changed from ``True`` in
0.7.0).
- .. note:: This functionality is now superceded by the
+ .. note:: This functionality is now superseded by the
``sqlalchemy.ext.mutable`` extension described in
:ref:`mutable_toplevel`.
meta.drop_all()
def test_boolean(self):
- """Test BOOL/TINYINT(1) compatability and reflection."""
+ """Test BOOL/TINYINT(1) compatibility and reflection."""
meta = MetaData(testing.db)
bool_table = Table(
eq_(conn2.execute(select([foo.c.data])).fetchall(), [('data1',
)])
- # connection supercedes statement
+ # connection supersedes statement
conn1.execution_options(autocommit=False).\
execute(select([func.insert_foo('data2'
# setting None on uninitialized is currently not a change for an
# object attribute (this is different than scalar attribute). a
- # lazyload has occured so if its None, its really None
+ # lazyload has occurred so if its None, its really None
f = Foo()
eq_(attributes.get_state_history(attributes.instance_state(f),
class MapperExtensionTest(_fixtures.FixtureTest):
- """Superceded by MapperEventsTest - test backwards
- compatiblity of MapperExtension."""
+ """Superseded by MapperEventsTest - test backwards
+ compatibility of MapperExtension."""
run_inserts = None
s.rollback()
assert u in s
- # but now its back, rollback has occured, the _remove_newly_deleted
+ # but now its back, rollback has occurred, the _remove_newly_deleted
# is reverted
eq_(u.name, 'chuck')
@testing.fails_on('maxdb', 'FIXME: unknown')
@testing.resolve_artifact_names
def test_refresh2(self):
- """test a hang condition that was occuring on expire/refresh"""
+ """test a hang condition that was occurring on expire/refresh"""
s = create_session()
mapper(Address, addresses)
)
def test_multi_tuple_form(self):
- """test the 'tuple' form of join, now superceded by the two-element join() form.
+ """test the 'tuple' form of join, now superseded by the two-element join() form.
Not deprecating this style as of yet.
@reconstructor
def go(self):
# blow away 'id', no change event.
- # this simulates a callable occuring
+ # this simulates a callable occurring
# before 'id' was even populated, i.e. a callable
# within an attribute_mapped_collection
self.__dict__.pop('id', None)
# and thing would right themselves.
assert_raises_message(sa.orm.exc.FlushError,
'has a NULL identity key. Check if this '
- 'flush is occuring at an inappropriate '
+ 'flush is occurring at an inappropriate '
'time, such as during a load operation.',
sess.query(T1).first)
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
