Fix many spell glitches

This affects mostly docstrings, except in orm/events.py::dispose_collection()
where one parameter gets renamed: given that the method is
empty, it seemed reasonable to me to fix that too.

Closes: #4440
Pull-request: https://github.com/sqlalchemy/sqlalchemy/pull/4440
Pull-request-sha: 779ed75acb6142e1f1daac467b5b14134529bb4b

Change-Id: Ic0553fe97853054b09c2453af76d96363de6eb0e

8 files changed, 21 insertions, 21 deletions

diff --git a/lib/sqlalchemy/sql/ddl.py b/lib/sqlalchemy/sql/ddl.py
index 954f769ef..d87a6a1b0 100644
--- a/lib/sqlalchemy/sql/ddl.py
+++ b/lib/sqlalchemy/sql/ddl.py
@@ -303,7 +303,7 @@ class DDL(DDLElement):
       connection.execute(drop_spow)
 
     When operating on Table events, the following ``statement``
-    string substitions are available::
+    string substitutions are available::
 
       %(table)s  - the Table name, with any required quoting applied
       %(schema)s - the schema name, with any required quoting applied
@@ -1045,7 +1045,7 @@ def sort_tables(tables, skip_fn=None, extra_dependencies=None):
         automatic resolution of dependency cycles between tables, which
         are usually caused by mutually dependent foreign key constraints.
         To resolve these cycles, either the
-        :paramref:`.ForeignKeyConstraint.use_alter` parameter may be appled
+        :paramref:`.ForeignKeyConstraint.use_alter` parameter may be applied
         to those constraints, or use the
         :func:`.sql.sort_tables_and_constraints` function which will break
         out foreign key constraints involved in cycles separately.
diff --git a/lib/sqlalchemy/sql/elements.py b/lib/sqlalchemy/sql/elements.py
index 71f346f45..9e4f5d95d 100644
--- a/lib/sqlalchemy/sql/elements.py
+++ b/lib/sqlalchemy/sql/elements.py
@@ -1089,7 +1089,7 @@ class BindParameter(ColumnElement):
           if True, this parameter will be treated as an "expanding" parameter
           at execution time; the parameter value is expected to be a sequence,
           rather than a scalar value, and the string SQL statement will
-          be transformed on a per-execution basis to accomodate the sequence
+          be transformed on a per-execution basis to accommodate the sequence
           with a variable number of parameter slots passed to the DBAPI.
           This is to allow statement caching to be used in conjunction with
           an IN clause.
diff --git a/lib/sqlalchemy/sql/operators.py b/lib/sqlalchemy/sql/operators.py
index 7277787e2..4206de460 100644
--- a/lib/sqlalchemy/sql/operators.py
+++ b/lib/sqlalchemy/sql/operators.py
@@ -690,7 +690,7 @@ class ColumnOperators(Operators):
         ``"%"`` and ``"_"`` that are present inside the <other> expression
         will behave like wildcards as well.   For literal string
         values, the :paramref:`.ColumnOperators.startswith.autoescape` flag
-        may be set to ``True`` to apply escaping to occurences of these
+        may be set to ``True`` to apply escaping to occurrences of these
         characters within the string value so that they match as themselves
         and not as wildcard characters.  Alternatively, the
         :paramref:`.ColumnOperators.startswith.escape` parameter will establish
@@ -778,7 +778,7 @@ class ColumnOperators(Operators):
         ``"%"`` and ``"_"`` that are present inside the <other> expression
         will behave like wildcards as well.   For literal string
         values, the :paramref:`.ColumnOperators.endswith.autoescape` flag
-        may be set to ``True`` to apply escaping to occurences of these
+        may be set to ``True`` to apply escaping to occurrences of these
         characters within the string value so that they match as themselves
         and not as wildcard characters.  Alternatively, the
         :paramref:`.ColumnOperators.endswith.escape` parameter will establish
@@ -866,7 +866,7 @@ class ColumnOperators(Operators):
         ``"%"`` and ``"_"`` that are present inside the <other> expression
         will behave like wildcards as well.   For literal string
         values, the :paramref:`.ColumnOperators.contains.autoescape` flag
-        may be set to ``True`` to apply escaping to occurences of these
+        may be set to ``True`` to apply escaping to occurrences of these
         characters within the string value so that they match as themselves
         and not as wildcard characters.  Alternatively, the
         :paramref:`.ColumnOperators.contains.escape` parameter will establish
@@ -950,7 +950,7 @@ class ColumnOperators(Operators):
         * Oracle - renders ``CONTAINS(x, y)``
         * other backends may provide special implementations.
         * Backends without any special implementation will emit
-          the operator as "MATCH".  This is compatible with SQlite, for
+          the operator as "MATCH".  This is compatible with SQLite, for
           example.
 
         """
diff --git a/lib/sqlalchemy/sql/schema.py b/lib/sqlalchemy/sql/schema.py
index d9555b196..07c0017b9 100644
--- a/lib/sqlalchemy/sql/schema.py
+++ b/lib/sqlalchemy/sql/schema.py
@@ -857,7 +857,7 @@ class Table(DialectKWArgs, SchemaItem, TableClause):
 
             m1 = MetaData()
 
-            user = Table('user', m1, Column('id', Integer, priamry_key=True))
+            user = Table('user', m1, Column('id', Integer, primary_key=True))
 
             m2 = MetaData()
             user_copy = user.tometadata(m2)
@@ -1494,7 +1494,7 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause):
             event.listen(self, "after_parent_attach", fn)
 
     def copy(self, **kw):
-        """Create a copy of this ``Column``, unitialized.
+        """Create a copy of this ``Column``, uninitialized.
 
         This is used in ``Table.tometadata``.
 
@@ -4028,7 +4028,7 @@ class MetaData(SchemaItem):
             automatic resolution of dependency cycles between tables, which
             are usually caused by mutually dependent foreign key constraints.
             To resolve these cycles, either the
-            :paramref:`.ForeignKeyConstraint.use_alter` parameter may be appled
+            :paramref:`.ForeignKeyConstraint.use_alter` parameter may be applied
             to those constraints, or use the
             :func:`.schema.sort_tables_and_constraints` function which will
             break out foreign key constraints involved in cycles separately.
@@ -4074,7 +4074,7 @@ class MetaData(SchemaItem):
           the existing bind on this ``MetaData``, if any.
 
         :param schema:
-          Optional, query and reflect tables from an alterate schema.
+          Optional, query and reflect tables from an alternate schema.
           If None, the schema associated with this :class:`.MetaData`
           is used, if any.
 
diff --git a/lib/sqlalchemy/sql/selectable.py b/lib/sqlalchemy/sql/selectable.py
index f48fa6f57..a5dee068c 100644
--- a/lib/sqlalchemy/sql/selectable.py
+++ b/lib/sqlalchemy/sql/selectable.py
@@ -1413,7 +1413,7 @@ class Lateral(Alias):
     level function as well as the :meth:`.FromClause.lateral` method available
     on all :class:`.FromClause` subclasses.
 
-    While LATERAL is part of the SQL standard, curently only more recent
+    While LATERAL is part of the SQL standard, currently only more recent
     PostgreSQL versions provide support for this keyword.
 
     .. versionadded:: 1.1
@@ -3256,7 +3256,7 @@ class Select(HasPrefixes, HasSuffixes, GenerativeSelect):
 
         When columns are omitted based on foreign key, the referred-to
         column is the one that's kept.  When columns are omitted based on
-        WHERE eqivalence, the first column in the columns clause is the
+        WHERE equivalence, the first column in the columns clause is the
         one that's kept.
 
         :param only_synonyms: when True, limit the removal of columns
diff --git a/lib/sqlalchemy/sql/sqltypes.py b/lib/sqlalchemy/sql/sqltypes.py
index 8131be443..8798f5ad7 100644
--- a/lib/sqlalchemy/sql/sqltypes.py
+++ b/lib/sqlalchemy/sql/sqltypes.py
@@ -588,7 +588,7 @@ class Numeric(_LookupExpressionAdapter, TypeEngine):
          be much longer due to decimal inaccuracy, and most floating point
          database types don't have a notion of "scale", so by default the
          float type looks for the first ten decimal places when converting.
-         Specfiying this value will override that length.  Types which
+         Specifying this value will override that length.  Types which
          do include an explicit ".scale" value, such as the base
          :class:`.Numeric` as well as the MySQL float types, will use the
          value of ".scale" as the default for decimal_return_scale, if not
@@ -597,7 +597,7 @@ class Numeric(_LookupExpressionAdapter, TypeEngine):
          .. versionadded:: 0.9.0
 
         When using the ``Numeric`` type, care should be taken to ensure
-        that the asdecimal setting is apppropriate for the DBAPI in use -
+        that the asdecimal setting is appropriate for the DBAPI in use -
         when Numeric applies a conversion from Decimal->float or float->
         Decimal, this conversion incurs an additional performance overhead
         for all result columns received.
@@ -739,7 +739,7 @@ class Float(Numeric):
          be much longer due to decimal inaccuracy, and most floating point
          database types don't have a notion of "scale", so by default the
          float type looks for the first ten decimal places when converting.
-         Specfiying this value will override that length.  Note that the
+         Specifying this value will override that length.  Note that the
          MySQL float types, which do include "scale", will use "scale"
          as the default for decimal_return_scale, if not otherwise specified.
 
@@ -1962,9 +1962,9 @@ class JSON(Indexable, TypeEngine):
     Index operations return an expression object whose type defaults to
     :class:`.JSON` by default, so that further JSON-oriented instructions may
     be called upon the result type.   Note that there are backend-specific
-    idiosyncracies here, including that the PostgreSQL database does not
+    idiosyncrasies here, including that the PostgreSQL database does not
     generally compare a "json" to a "json" structure without type casts.  These
-    idiosyncracies can be accommodated in a backend-neutral way by making
+    idiosyncrasies can be accommodated in a backend-neutral way by making
     explicit use of the :func:`.cast` and :func:`.type_coerce` constructs.
     Comparison of specific index elements of a :class:`.JSON` object to other
     objects works best if the **left hand side is CAST to a string** and the
diff --git a/lib/sqlalchemy/sql/type_api.py b/lib/sqlalchemy/sql/type_api.py
index 2c01484eb..9e052c6b4 100644
--- a/lib/sqlalchemy/sql/type_api.py
+++ b/lib/sqlalchemy/sql/type_api.py
@@ -185,7 +185,7 @@ class TypeEngine(Visitable):
 
         .. note::
 
-            The "evaulates none" flag does **not** apply to a value
+            The "evaluates none" flag does **not** apply to a value
             of ``None`` passed to :paramref:`.Column.default` or
             :paramref:`.Column.server_default`; in these cases, ``None``
             still means "no default".
@@ -218,7 +218,7 @@ class TypeEngine(Visitable):
         where it can be consumed by schema comparison tools such as
         Alembic autogenerate.
 
-        A future release of SQLAlchemy will potentially impement this method
+        A future release of SQLAlchemy will potentially implement this method
         for builtin types as well.
 
         The function should return True if this type is equivalent to the
diff --git a/lib/sqlalchemy/sql/util.py b/lib/sqlalchemy/sql/util.py
index 9780caa1c..5a44f873d 100644
--- a/lib/sqlalchemy/sql/util.py
+++ b/lib/sqlalchemy/sql/util.py
@@ -116,7 +116,7 @@ def find_left_clause_to_join_from(clauses, join_to, onclause):
     and optional ON clause, return a list of integer indexes from the
     clauses list indicating the clauses that can be joined from.
 
-    The presense of an "onclause" indicates that at least one clause can
+    The presence of an "onclause" indicates that at least one clause can
     definitely be joined from; if the list of clauses is of length one
     and the onclause is given, returns that index.   If the list of clauses
     is more than length one, and the onclause is given, attempts to locate