spelling: Postgresql -> PostgreSQL

9 files changed, 40 insertions, 40 deletions

diff --git a/lib/sqlalchemy/sql/ddl.py b/lib/sqlalchemy/sql/ddl.py
index a48dec46f..427886749 100644
--- a/lib/sqlalchemy/sql/ddl.py
+++ b/lib/sqlalchemy/sql/ddl.py
@@ -570,10 +570,10 @@ class CreateColumn(_DDLCompiles):
     as an implicitly-present "system" column.
 
     For example, suppose we wish to produce a :class:`.Table` which skips
-    rendering of the Postgresql ``xmin`` column against the Postgresql
+    rendering of the PostgreSQL ``xmin`` column against the PostgreSQL
     backend, but on other backends does render it, in anticipation of a
     triggered rule.  A conditional compilation rule could skip this name only
-    on Postgresql::
+    on PostgreSQL::
 
         from sqlalchemy.schema import CreateColumn
 
@@ -592,7 +592,7 @@ class CreateColumn(_DDLCompiles):
 
     Above, a :class:`.CreateTable` construct will generate a ``CREATE TABLE``
     which only includes the ``id`` column in the string; the ``xmin`` column
-    will be omitted, but only against the Postgresql backend.
+    will be omitted, but only against the PostgreSQL backend.
 
     .. versionadded:: 0.8.3 The :class:`.CreateColumn` construct supports
        skipping of columns by returning ``None`` from a custom compilation
diff --git a/lib/sqlalchemy/sql/dml.py b/lib/sqlalchemy/sql/dml.py
index 480b5ba7f..1f6c155e8 100644
--- a/lib/sqlalchemy/sql/dml.py
+++ b/lib/sqlalchemy/sql/dml.py
@@ -255,7 +255,7 @@ class ValuesBase(UpdateBase):
          The :class:`.Insert` construct also supports being passed a list
          of dictionaries or full-table-tuples, which on the server will
          render the less common SQL syntax of "multiple values" - this
-         syntax is supported on backends such as SQLite, Postgresql, MySQL,
+         syntax is supported on backends such as SQLite, PostgreSQL, MySQL,
          but not necessarily others::
 
             users.insert().values([
diff --git a/lib/sqlalchemy/sql/elements.py b/lib/sqlalchemy/sql/elements.py
index 768574c1a..3abc2b1ba 100644
--- a/lib/sqlalchemy/sql/elements.py
+++ b/lib/sqlalchemy/sql/elements.py
@@ -954,7 +954,7 @@ class BindParameter(ColumnElement):
 
         Above, we see that ``Wendy`` is passed as a parameter to the database,
         while the placeholder ``:name_1`` is rendered in the appropriate form
-        for the target database, in this case the Postgresql database.
+        for the target database, in this case the PostgreSQL database.
 
         Similarly, :func:`.bindparam` is invoked automatically
         when working with :term:`CRUD` statements as far as the "VALUES"
@@ -1999,7 +1999,7 @@ class Tuple(ClauseList, ColumnElement):
         .. warning::
 
             The composite IN construct is not supported by all backends,
-            and is currently known to work on Postgresql and MySQL,
+            and is currently known to work on PostgreSQL and MySQL,
             but not SQLite.   Unsupported backends will raise
             a subclass of :class:`~sqlalchemy.exc.DBAPIError` when such
             an expression is invoked.
@@ -2808,7 +2808,7 @@ class CollectionAggregate(UnaryExpression):
     ANY and ALL.
 
     The ANY and ALL keywords are available in different ways on different
-    backends.  On Postgresql, they only work for an ARRAY type.  On
+    backends.  On PostgreSQL, they only work for an ARRAY type.  On
     MySQL, they only work for subqueries.
 
     """
@@ -3006,7 +3006,7 @@ class Slice(ColumnElement):
     """Represent SQL for a Python array-slice object.
 
     This is not a specific SQL construct at this level, but
-    may be interpreted by specific dialects, e.g. Postgresql.
+    may be interpreted by specific dialects, e.g. PostgreSQL.
 
     """
     __visit_name__ = 'slice'
diff --git a/lib/sqlalchemy/sql/functions.py b/lib/sqlalchemy/sql/functions.py
index 5c977cd50..69a9a9ac7 100644
--- a/lib/sqlalchemy/sql/functions.py
+++ b/lib/sqlalchemy/sql/functions.py
@@ -196,7 +196,7 @@ class FunctionElement(Executable, ColumnElement, FromClause):
 
         This construct wraps the function in a named alias which
         is suitable for the FROM clause, in the style accepted for example
-        by Postgresql.
+        by PostgreSQL.
 
         e.g.::
 
diff --git a/lib/sqlalchemy/sql/operators.py b/lib/sqlalchemy/sql/operators.py
index 69eee28ab..6eb4f0a75 100644
--- a/lib/sqlalchemy/sql/operators.py
+++ b/lib/sqlalchemy/sql/operators.py
@@ -365,7 +365,7 @@ class ColumnOperators(Operators):
         """Implement the [] operator.
 
         This can be used by some database-specific types
-        such as Postgresql ARRAY and HSTORE.
+        such as PostgreSQL ARRAY and HSTORE.
 
         """
         return self.operate(getitem, index)
@@ -557,7 +557,7 @@ class ColumnOperators(Operators):
         a MATCH-like function or operator provided by the backend.
         Examples include:
 
-        * Postgresql - renders ``x @@ to_tsquery(y)``
+        * PostgreSQL - renders ``x @@ to_tsquery(y)``
         * MySQL - renders ``MATCH (x) AGAINST (y IN BOOLEAN MODE)``
         * Oracle - renders ``CONTAINS(x, y)``
         * other backends may provide special implementations.
diff --git a/lib/sqlalchemy/sql/schema.py b/lib/sqlalchemy/sql/schema.py
index fe98138ad..df7e419ca 100644
--- a/lib/sqlalchemy/sql/schema.py
+++ b/lib/sqlalchemy/sql/schema.py
@@ -942,7 +942,7 @@ class Column(SchemaItem, ColumnClause):
           an INTEGER type with no stated client-side or python-side defaults
           should receive auto increment semantics automatically;
           all other varieties of primary key columns will not.  This
-          includes that :term:`DDL` such as Postgresql SERIAL or MySQL
+          includes that :term:`DDL` such as PostgreSQL SERIAL or MySQL
           AUTO_INCREMENT will be emitted for this column during a table
           create, as well as that the column is assumed to generate new
           integer primary key values when an INSERT statement invokes which
@@ -995,7 +995,7 @@ class Column(SchemaItem, ColumnClause):
           * DDL issued for the column will include database-specific
             keywords intended to signify this column as an
             "autoincrement" column, such as AUTO INCREMENT on MySQL,
-            SERIAL on Postgresql, and IDENTITY on MS-SQL.  It does
+            SERIAL on PostgreSQL, and IDENTITY on MS-SQL.  It does
             *not* issue AUTOINCREMENT for SQLite since this is a
             special SQLite flag that is not required for autoincrementing
             behavior.
@@ -2174,7 +2174,7 @@ class Sequence(DefaultGenerator):
          :class:`.Sequence` object only needs to be explicitly generated
          on backends that don't provide another way to generate primary
          key identifiers.  Currently, it essentially means, "don't create
-         this sequence on the Postgresql backend, where the SERIAL keyword
+         this sequence on the PostgreSQL backend, where the SERIAL keyword
          creates a sequence for us automatically".
         :param quote: boolean value, when ``True`` or ``False``, explicitly
          forces quoting of the schema name on or off.  When left at its
diff --git a/lib/sqlalchemy/sql/selectable.py b/lib/sqlalchemy/sql/selectable.py
index 43aff7caa..ca4183e3e 100644
--- a/lib/sqlalchemy/sql/selectable.py
+++ b/lib/sqlalchemy/sql/selectable.py
@@ -171,7 +171,7 @@ def lateral(selectable, name=None):
     FROM clause of an enclosing SELECT, but may correlate to other
     FROM clauses of that SELECT.   It is a special case of subquery
     only supported by a small number of backends, currently more recent
-    Postgresql versions.
+    PostgreSQL versions.
 
     .. versionadded:: 1.1
 
@@ -1315,7 +1315,7 @@ class Lateral(Alias):
     on all :class:`.FromClause` subclasses.
 
     While LATERAL is part of the SQL standard, curently only more recent
-    Postgresql versions provide support for this keyword.
+    PostgreSQL versions provide support for this keyword.
 
     .. versionadded:: 1.1
 
@@ -1469,7 +1469,7 @@ class HasCTE(object):
          conjunction with UNION ALL in order to derive rows
          from those already selected.
 
-        The following examples include two from Postgresql's documentation at
+        The following examples include two from PostgreSQL's documentation at
         http://www.postgresql.org/docs/current/static/queries-with.html,
         as well as additional examples.
 
@@ -2005,7 +2005,7 @@ class GenerativeSelect(SelectBase):
 
             stmt = select([table]).with_for_update(nowait=True)
 
-        On a database like Postgresql or Oracle, the above would render a
+        On a database like PostgreSQL or Oracle, the above would render a
         statement like::
 
             SELECT table.a, table.b FROM table FOR UPDATE NOWAIT
@@ -2021,10 +2021,10 @@ class GenerativeSelect(SelectBase):
         variants.
 
         :param nowait: boolean; will render ``FOR UPDATE NOWAIT`` on Oracle
-         and Postgresql dialects.
+         and PostgreSQL dialects.
 
         :param read: boolean; will render ``LOCK IN SHARE MODE`` on MySQL,
-         ``FOR SHARE`` on Postgresql.  On Postgresql, when combined with
+         ``FOR SHARE`` on PostgreSQL.  On PostgreSQL, when combined with
          ``nowait``, will render ``FOR SHARE NOWAIT``.
 
         :param of: SQL expression or list of SQL expression elements
@@ -2034,14 +2034,14 @@ class GenerativeSelect(SelectBase):
          backend.
 
         :param skip_locked: boolean, will render ``FOR UPDATE SKIP LOCKED``
-         on Oracle and Postgresql dialects or ``FOR SHARE SKIP LOCKED`` if
+         on Oracle and PostgreSQL dialects or ``FOR SHARE SKIP LOCKED`` if
          ``read=True`` is also specified.
 
          .. versionadded:: 1.1.0
 
         :param key_share: boolean, will render ``FOR NO KEY UPDATE``,
          or if combined with ``read=True`` will render ``FOR KEY SHARE``,
-         on the Postgresql dialect.
+         on the PostgreSQL dialect.
 
          .. versionadded:: 1.1.0
 
@@ -2585,7 +2585,7 @@ class Select(HasPrefixes, HasSuffixes, GenerativeSelect):
 
           The boolean argument may also be a column expression or list
           of column expressions - this is a special calling form which
-          is understood by the Postgresql dialect to render the
+          is understood by the PostgreSQL dialect to render the
           ``DISTINCT ON (<columns>)`` syntax.
 
           ``distinct`` is also available on an existing :class:`.Select`
@@ -2607,10 +2607,10 @@ class Select(HasPrefixes, HasSuffixes, GenerativeSelect):
           specific backends, including:
 
           * ``"read"`` - on MySQL, translates to ``LOCK IN SHARE MODE``;
-            on Postgresql, translates to ``FOR SHARE``.
-          * ``"nowait"`` - on Postgresql and Oracle, translates to
+            on PostgreSQL, translates to ``FOR SHARE``.
+          * ``"nowait"`` - on PostgreSQL and Oracle, translates to
             ``FOR UPDATE NOWAIT``.
-          * ``"read_nowait"`` - on Postgresql, translates to
+          * ``"read_nowait"`` - on PostgreSQL, translates to
             ``FOR SHARE NOWAIT``.
 
          .. seealso::
@@ -3177,7 +3177,7 @@ class Select(HasPrefixes, HasSuffixes, GenerativeSelect):
         columns clause.
 
         :param \*expr: optional column expressions.  When present,
-         the Postgresql dialect will render a ``DISTINCT ON (<expressions>>)``
+         the PostgreSQL dialect will render a ``DISTINCT ON (<expressions>>)``
          construct.
 
         """
diff --git a/lib/sqlalchemy/sql/sqltypes.py b/lib/sqlalchemy/sql/sqltypes.py
index 66e5f3e93..78547ccf0 100644
--- a/lib/sqlalchemy/sql/sqltypes.py
+++ b/lib/sqlalchemy/sql/sqltypes.py
@@ -141,7 +141,7 @@ class String(Concatenable, TypeEngine):
 
         :param collation: Optional, a column-level collation for
           use in DDL and CAST expressions.  Renders using the
-          COLLATE keyword supported by SQLite, MySQL, and Postgresql.
+          COLLATE keyword supported by SQLite, MySQL, and PostgreSQL.
           E.g.::
 
             >>> from sqlalchemy import cast, select, String
@@ -923,7 +923,7 @@ class LargeBinary(_Binary):
 
     The :class:`.LargeBinary` type corresponds to a large and/or unlengthed
     binary type for the target platform, such as BLOB on MySQL and BYTEA for
-    Postgresql.  It also handles the necessary conversions for the DBAPI.
+    PostgreSQL.  It also handles the necessary conversions for the DBAPI.
 
     """
 
@@ -1177,7 +1177,7 @@ class Enum(String, SchemaType):
 
         :param metadata: Associate this type directly with a ``MetaData``
            object. For types that exist on the target database as an
-           independent schema construct (Postgresql), this type will be
+           independent schema construct (PostgreSQL), this type will be
            created and dropped within ``create_all()`` and ``drop_all()``
            operations. If the type is not associated with any ``MetaData``
            object, it will associate itself with each ``Table`` in which it is
@@ -1186,7 +1186,7 @@ class Enum(String, SchemaType):
            only dropped when ``drop_all()`` is called for that ``Table``
            object's metadata, however.
 
-        :param name: The name of this type. This is required for Postgresql
+        :param name: The name of this type. This is required for PostgreSQL
            and any future supported database which requires an explicitly
            named type, or an explicitly named constraint in order to generate
            the type and/or a table that uses it. If a PEP-435 enumerated
@@ -1198,7 +1198,7 @@ class Enum(String, SchemaType):
            constraint for all backends.
 
         :param schema: Schema name of this type. For types that exist on the
-           target database as an independent schema construct (Postgresql),
+           target database as an independent schema construct (PostgreSQL),
            this parameter specifies the named schema in which the type is
            present.
 
@@ -1572,13 +1572,13 @@ class Interval(_DateAffinity, TypeDecorator):
 
         :param native: when True, use the actual
           INTERVAL type provided by the database, if
-          supported (currently Postgresql, Oracle).
+          supported (currently PostgreSQL, Oracle).
           Otherwise, represent the interval data as
           an epoch value regardless.
 
         :param second_precision: For native interval types
           which support a "fractional seconds precision" parameter,
-          i.e. Oracle and Postgresql
+          i.e. Oracle and PostgreSQL
 
         :param day_precision: for native interval types which
           support a "day precision" parameter, i.e. Oracle.
@@ -1673,7 +1673,7 @@ class JSON(Indexable, TypeEngine):
     .. note::  :class:`.types.JSON` is provided as a facade for vendor-specific
        JSON types.  Since it supports JSON SQL operations, it only
        works on backends that have an actual JSON type, currently
-       Postgresql as well as certain versions of MySQL.
+       PostgreSQL as well as certain versions of MySQL.
 
     :class:`.types.JSON` is part of the Core in support of the growing
     popularity of native JSON datatypes.
@@ -1927,7 +1927,7 @@ class ARRAY(Indexable, Concatenable, TypeEngine):
     """Represent a SQL Array type.
 
     .. note::  This type serves as the basis for all ARRAY operations.
-       However, currently **only the Postgresql backend has support
+       However, currently **only the PostgreSQL backend has support
        for SQL arrays in SQLAlchemy**.  It is recommended to use the
        :class:`.postgresql.ARRAY` type directly when using ARRAY types
        with PostgreSQL, as it provides additional operators specific
@@ -1947,7 +1947,7 @@ class ARRAY(Indexable, Concatenable, TypeEngine):
             )
 
     The above type represents an N-dimensional array,
-    meaning a supporting backend such as Postgresql will interpret values
+    meaning a supporting backend such as PostgreSQL will interpret values
     with any number of dimensions automatically.   To produce an INSERT
     construct that passes in a 1-dimensional array of integers::
 
@@ -2243,7 +2243,7 @@ class TIMESTAMP(DateTime):
     """The SQL TIMESTAMP type.
 
     :class:`~.types.TIMESTAMP` datatypes have support for timezone
-    storage on some backends, such as Postgresql and Oracle.  Use the
+    storage on some backends, such as PostgreSQL and Oracle.  Use the
     :paramref:`~types.TIMESTAMP.timezone` argument in order to enable
     "TIMESTAMP WITH TIMEZONE" for these backends.
 
diff --git a/lib/sqlalchemy/sql/type_api.py b/lib/sqlalchemy/sql/type_api.py
index ab12f4435..217f7016b 100644
--- a/lib/sqlalchemy/sql/type_api.py
+++ b/lib/sqlalchemy/sql/type_api.py
@@ -80,7 +80,7 @@ class TypeEngine(Visitable):
             However, using the addition operator with an :class:`.Integer`
             and a :class:`.Date` object will produce a :class:`.Date`, assuming
             "days delta" behavior by the database (in reality, most databases
-            other than Postgresql don't accept this particular operation).
+            other than PostgreSQL don't accept this particular operation).
 
             The method returns a tuple of the form <operator>, <type>.
             The resulting operator and type will be those applied to the
@@ -188,7 +188,7 @@ class TypeEngine(Visitable):
 
             :ref:`session_forcing_null` - in the ORM documentation
 
-            :paramref:`.postgresql.JSON.none_as_null` - Postgresql JSON
+            :paramref:`.postgresql.JSON.none_as_null` - PostgreSQL JSON
             interaction with this flag.
 
             :attr:`.TypeEngine.should_evaluate_none` - class-level flag