def render_literal_value(self, value, type_):
"""Render the value of a bind parameter as a quoted literal.
- This is used for statement sections that do not accept bind paramters
+ This is used for statement sections that do not accept bind parameters
on the target driver/database.
This should be implemented by subclasses using the quoting services
else:
return self.quote(name, column.quote)
else:
- # literal textual elements get stuck into ColumnClause alot,
- # which shouldnt get quoted
+ # literal textual elements get stuck into ColumnClause a lot,
+ # which shouldn't get quoted
if use_table:
return self.format_table(column.table,
@util.memoized_property
def _cloned_set(self):
- """Return the set consisting all cloned anscestors of this
+ """Return the set consisting all cloned ancestors of this
ClauseElement.
Includes this ClauseElement. This accessor tends to be used for
return self._clone()
def unique_params(self, *optionaldict, **kwargs):
- """Return a copy with :func:`bindparam()` elments replaced.
+ """Return a copy with :func:`bindparam()` elements replaced.
Same functionality as ``params()``, except adds `unique=True`
to affected bind parameters so that multiple statements can be
return self._params(True, optionaldict, kwargs)
def params(self, *optionaldict, **kwargs):
- """Return a copy with :func:`bindparam()` elments replaced.
+ """Return a copy with :func:`bindparam()` elements replaced.
Returns a copy of this ClauseElement with :func:`bindparam()`
elements replaced with values taken from the given dictionary::
compiled statement. If ``None``, all columns from the target table
object are rendered.
- :param dialect: A ``Dialect`` instance frmo which a ``Compiled``
+ :param dialect: A ``Dialect`` instance from which a ``Compiled``
will be acquired. This argument takes precedence over the `bind`
argument as well as this :class:`.ClauseElement`'s bound engine, if
any.
return self._negate()
def __nonzero__(self):
- raise TypeError("Boolean value of this clause is not defined")
+ raise TypeError("Boolean value of this clause is not defined")
def _negate(self):
if hasattr(self, 'negation_clause'):
:param equivalents: a dictionary of columns as keys mapped to sets
of columns. If the given "other" column is present in this
- dictionary, if any of the columns in the correponding set() pass the
+ dictionary, if any of the columns in the corresponding set() pass the
comparison test, the result is True. This is used to expand the
comparison to other columns that may be known to be equivalent to
this one via foreign key or other criterion.
"""Given a :class:`.ColumnElement`, return the exported
:class:`.ColumnElement` object from this :class:`.Selectable`
which corresponds to that original
- :class:`~sqlalchemy.schema.Column` via a common anscestor
+ :class:`~sqlalchemy.schema.Column` via a common ancestor
column.
:param column: the target :class:`.ColumnElement` to be matched
the given :class:`.ColumnElement`, if the given
:class:`.ColumnElement` is actually present within a sub-element
of this :class:`.FromClause`. Normally the column will match if
- it merely shares a common anscestor with one of the exported
+ it merely shares a common ancestor with one of the exported
columns of this :class:`.FromClause`.
"""
return False
return True
- # dont dig around if the column is locally present
+ # don't dig around if the column is locally present
if self.c.contains_column(column):
return column
col, intersect = None, None
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
self.key = key or _anonymous_label('%%(%d param)s'
% id(self))
- # identifiying key that won't change across
+ # identifying key that won't change across
# clones, used to identify the bind's logical
# identity
self._identifying_key = self.key
@property
def columns(self):
- """Fulfill the 'columns' contrct of :class:`.ColumnElement`.
+ """Fulfill the 'columns' contract of :class:`.ColumnElement`.
Returns a single-element list consisting of this object.
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
