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):
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)
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
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`.
"""
@util.accepts_a_list_as_starargs(list_deprecation='deprecated')
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
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
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`.
"""
# 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)
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'
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)
@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
