Commits

diana committed 1bbba2e

typos in lib/sqlalchemy/sql

Comments (0)

Files changed (2)

lib/sqlalchemy/sql/compiler.py

     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,

lib/sqlalchemy/sql/expression.py

 
     @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.
 
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.