diff options
Diffstat (limited to 'lib/sqlalchemy')
28 files changed, 135 insertions, 135 deletions
diff --git a/lib/sqlalchemy/dialects/postgresql/array.py b/lib/sqlalchemy/dialects/postgresql/array.py index fe62eb101..0ad457c59 100644 --- a/lib/sqlalchemy/dialects/postgresql/array.py +++ b/lib/sqlalchemy/dialects/postgresql/array.py @@ -46,7 +46,7 @@ def All(other, arrexpr, operator=operators.eq): class array(expression.Tuple): - """A Postgresql ARRAY literal. + """A PostgreSQL ARRAY literal. This is used to produce ARRAY literals in SQL expressions, e.g.:: @@ -116,7 +116,7 @@ OVERLAP = operators.custom_op("&&", precedence=5) class ARRAY(SchemaEventTarget, sqltypes.ARRAY): - """Postgresql ARRAY type. + """PostgreSQL ARRAY type. .. versionchanged:: 1.1 The :class:`.postgresql.ARRAY` type is now a subclass of the core :class:`.types.ARRAY` type. @@ -219,7 +219,7 @@ class ARRAY(SchemaEventTarget, sqltypes.ARRAY): they were declared. :param zero_indexes=False: when True, index values will be converted - between Python zero-based and Postgresql one-based indexes, e.g. + between Python zero-based and PostgreSQL one-based indexes, e.g. a value of one will be added to all index values before passing to the database. diff --git a/lib/sqlalchemy/dialects/postgresql/base.py b/lib/sqlalchemy/dialects/postgresql/base.py index bde855fbe..85f82ec60 100644 --- a/lib/sqlalchemy/dialects/postgresql/base.py +++ b/lib/sqlalchemy/dialects/postgresql/base.py @@ -30,7 +30,7 @@ When SQLAlchemy issues a single INSERT statement, to fulfill the contract of having the "last insert identifier" available, a RETURNING clause is added to the INSERT statement which specifies the primary key columns should be returned after the statement completes. The RETURNING functionality only takes -place if Postgresql 8.2 or later is in use. As a fallback approach, the +place if PostgreSQL 8.2 or later is in use. As a fallback approach, the sequence, whether specified explicitly or implicitly via ``SERIAL``, is executed independently beforehand, the returned value to be used in the subsequent insert. Note that when an @@ -47,7 +47,7 @@ To force the usage of RETURNING by default off, specify the flag Transaction Isolation Level --------------------------- -All Postgresql dialects support setting of transaction isolation level +All PostgreSQL dialects support setting of transaction isolation level both via a dialect-specific parameter :paramref:`.create_engine.isolation_level` accepted by :func:`.create_engine`, as well as the :paramref:`.Connection.execution_options.isolation_level` @@ -87,10 +87,10 @@ Valid values for ``isolation_level`` include: .. _postgresql_schema_reflection: -Remote-Schema Table Introspection and Postgresql search_path +Remote-Schema Table Introspection and PostgreSQL search_path ------------------------------------------------------------ -The Postgresql dialect can reflect tables from any schema. The +The PostgreSQL dialect can reflect tables from any schema. The :paramref:`.Table.schema` argument, or alternatively the :paramref:`.MetaData.reflect.schema` argument determines which schema will be searched for the table or tables. The reflected :class:`.Table` objects @@ -99,14 +99,14 @@ However, with regards to tables which these :class:`.Table` objects refer to via foreign key constraint, a decision must be made as to how the ``.schema`` is represented in those remote tables, in the case where that remote schema name is also a member of the current -`Postgresql search path +`PostgreSQL search path <http://www.postgresql.org/docs/current/static/ddl-schemas.html#DDL-SCHEMAS-PATH>`_. -By default, the Postgresql dialect mimics the behavior encouraged by -Postgresql's own ``pg_get_constraintdef()`` builtin procedure. This function +By default, the PostgreSQL dialect mimics the behavior encouraged by +PostgreSQL's own ``pg_get_constraintdef()`` builtin procedure. This function returns a sample definition for a particular foreign key constraint, omitting the referenced schema name from that definition when the name is -also in the Postgresql schema search path. The interaction below +also in the PostgreSQL schema search path. The interaction below illustrates this behavior:: test=> CREATE TABLE test_schema.referred(id INTEGER PRIMARY KEY); @@ -193,9 +193,9 @@ We will now have ``test_schema.referred`` stored as schema-qualified:: >>> meta.tables['test_schema.referred'].schema 'test_schema' -.. sidebar:: Best Practices for Postgresql Schema reflection +.. sidebar:: Best Practices for PostgreSQL Schema reflection - The description of Postgresql schema reflection behavior is complex, and + The description of PostgreSQL schema reflection behavior is complex, and is the product of many years of dealing with widely varied use cases and user preferences. But in fact, there's no need to understand any of it if you just stick to the simplest use pattern: leave the ``search_path`` set @@ -206,8 +206,8 @@ We will now have ``test_schema.referred`` stored as schema-qualified:: within these guidelines. Note that **in all cases**, the "default" schema is always reflected as -``None``. The "default" schema on Postgresql is that which is returned by the -Postgresql ``current_schema()`` function. On a typical Postgresql +``None``. The "default" schema on PostgreSQL is that which is returned by the +PostgreSQL ``current_schema()`` function. On a typical PostgreSQL installation, this is the name ``public``. So a table that refers to another which is in the ``public`` (i.e. default) schema will always have the ``.schema`` attribute set to ``None``. @@ -221,7 +221,7 @@ which is in the ``public`` (i.e. default) schema will always have the `The Schema Search Path <http://www.postgresql.org/docs/9.0/static/ddl-schemas.html#DDL-SCHEMAS-PATH>`_ - - on the Postgresql website. + - on the PostgreSQL website. INSERT/UPDATE...RETURNING ------------------------- @@ -265,7 +265,7 @@ constraints may be identified either using their name as stated in DDL, or they may be *inferred* by stating the columns and conditions that comprise the indexes. -SQLAlchemy provides ``ON CONFLICT`` support via the Postgresql-specific +SQLAlchemy provides ``ON CONFLICT`` support via the PostgreSQL-specific :func:`.postgresql.dml.insert()` function, which provides the generative methods :meth:`~.postgresql.dml.Insert.on_conflict_do_update` and :meth:`~.postgresql.dml.Insert.on_conflict_do_nothing`:: @@ -432,20 +432,20 @@ constraint violation which occurs:: stmt = stmt.on_conflict_do_nothing() conn.execute(stmt) -.. versionadded:: 1.1 Added support for Postgresql ON CONFLICT clauses +.. versionadded:: 1.1 Added support for PostgreSQL ON CONFLICT clauses .. seealso:: - `INSERT .. ON CONFLICT <http://www.postgresql.org/docs/current/static/sql-insert.html#SQL-ON-CONFLICT>`_ - in the Postgresql documentation. + `INSERT .. ON CONFLICT <http://www.postgresql.org/docs/current/static/sql-insert.html#SQL-ON-CONFLICT>`_ - in the PostgreSQL documentation. .. _postgresql_match: Full Text Search ---------------- -SQLAlchemy makes available the Postgresql ``@@`` operator via the +SQLAlchemy makes available the PostgreSQL ``@@`` operator via the :meth:`.ColumnElement.match` method on any textual column expression. -On a Postgresql dialect, an expression like the following:: +On a PostgreSQL dialect, an expression like the following:: select([sometable.c.text.match("search string")]) @@ -453,7 +453,7 @@ will emit to the database:: SELECT text @@ to_tsquery('search string') FROM table -The Postgresql text search functions such as ``to_tsquery()`` +The PostgreSQL text search functions such as ``to_tsquery()`` and ``to_tsvector()`` are available explicitly using the standard :data:`.func` construct. For example:: @@ -475,7 +475,7 @@ produces a statement equivalent to:: SELECT CAST('some text' AS TSVECTOR) AS anon_1 -Full Text Searches in Postgresql are influenced by a combination of: the +Full Text Searches in PostgreSQL are influenced by a combination of: the PostgresSQL setting of ``default_text_search_config``, the ``regconfig`` used to build the GIN/GiST indexes, and the ``regconfig`` optionally passed in during a query. @@ -539,7 +539,7 @@ syntaxes. It uses SQLAlchemy's hints mechanism:: .. _postgresql_indexes: -Postgresql-Specific Index Options +PostgreSQL-Specific Index Options --------------------------------- Several extensions to the :class:`.Index` construct are available, specific @@ -622,7 +622,7 @@ Note that the same option is available on :class:`.Table` as well. Indexes with CONCURRENTLY ^^^^^^^^^^^^^^^^^^^^^^^^^ -The Postgresql index option CONCURRENTLY is supported by passing the +The PostgreSQL index option CONCURRENTLY is supported by passing the flag ``postgresql_concurrently`` to the :class:`.Index` construct:: tbl = Table('testtbl', m, Column('data', Integer)) @@ -630,27 +630,27 @@ flag ``postgresql_concurrently`` to the :class:`.Index` construct:: idx1 = Index('test_idx1', tbl.c.data, postgresql_concurrently=True) The above index construct will render DDL for CREATE INDEX, assuming -Postgresql 8.2 or higher is detected or for a connection-less dialect, as:: +PostgreSQL 8.2 or higher is detected or for a connection-less dialect, as:: CREATE INDEX CONCURRENTLY test_idx1 ON testtbl (data) -For DROP INDEX, assuming Postgresql 9.2 or higher is detected or for +For DROP INDEX, assuming PostgreSQL 9.2 or higher is detected or for a connection-less dialect, it will emit:: DROP INDEX CONCURRENTLY test_idx1 .. versionadded:: 1.1 support for CONCURRENTLY on DROP INDEX. The CONCURRENTLY keyword is now only emitted if a high enough version - of Postgresql is detected on the connection (or for a connection-less + of PostgreSQL is detected on the connection (or for a connection-less dialect). .. _postgresql_index_reflection: -Postgresql Index Reflection +PostgreSQL Index Reflection --------------------------- -The Postgresql database creates a UNIQUE INDEX implicitly whenever the +The PostgreSQL database creates a UNIQUE INDEX implicitly whenever the UNIQUE CONSTRAINT construct is used. When inspecting a table using :class:`.Inspector`, the :meth:`.Inspector.get_indexes` and the :meth:`.Inspector.get_unique_constraints` will report on these @@ -663,14 +663,14 @@ in :attr:`.Table.indexes` when it is detected as mirroring a .. versionchanged:: 1.0.0 - :class:`.Table` reflection now includes :class:`.UniqueConstraint` objects present in the :attr:`.Table.constraints` - collection; the Postgresql backend will no longer include a "mirrored" + collection; the PostgreSQL backend will no longer include a "mirrored" :class:`.Index` construct in :attr:`.Table.indexes` if it is detected as corresponding to a unique constraint. Special Reflection Options -------------------------- -The :class:`.Inspector` used for the Postgresql backend is an instance +The :class:`.Inspector` used for the PostgreSQL backend is an instance of :class:`.PGInspector`, which offers additional methods:: from sqlalchemy import create_engine, inspect @@ -719,13 +719,13 @@ dialect in conjunction with the :class:`.Table` construct: .. seealso:: - `Postgresql CREATE TABLE options + `PostgreSQL CREATE TABLE options <http://www.postgresql.org/docs/current/static/sql-createtable.html>`_ ARRAY Types ----------- -The Postgresql dialect supports arrays, both as multidimensional column types +The PostgreSQL dialect supports arrays, both as multidimensional column types as well as array literals: * :class:`.postgresql.ARRAY` - ARRAY datatype @@ -740,8 +740,8 @@ as well as array literals: JSON Types ---------- -The Postgresql dialect supports both JSON and JSONB datatypes, including -psycopg2's native support and support for all of Postgresql's special +The PostgreSQL dialect supports both JSON and JSONB datatypes, including +psycopg2's native support and support for all of PostgreSQL's special operators: * :class:`.postgresql.JSON` @@ -751,7 +751,7 @@ operators: HSTORE Type ----------- -The Postgresql HSTORE type as well as hstore literals are supported: +The PostgreSQL HSTORE type as well as hstore literals are supported: * :class:`.postgresql.HSTORE` - HSTORE datatype @@ -760,7 +760,7 @@ The Postgresql HSTORE type as well as hstore literals are supported: ENUM Types ---------- -Postgresql has an independently creatable TYPE structure which is used +PostgreSQL has an independently creatable TYPE structure which is used to implement an enumerated type. This approach introduces significant complexity on the SQLAlchemy side in terms of when this type should be CREATED and DROPPED. The type object is also an independently reflectable @@ -881,7 +881,7 @@ PGMacAddr = MACADDR class OID(sqltypes.TypeEngine): - """Provide the Postgresql OID type. + """Provide the PostgreSQL OID type. .. versionadded:: 0.9.5 @@ -905,7 +905,7 @@ class TIME(sqltypes.TIME): class INTERVAL(sqltypes.TypeEngine): - """Postgresql INTERVAL type. + """PostgreSQL INTERVAL type. The INTERVAL type may not be supported on all DBAPIs. It is known to work on psycopg2 and not pg8000 or zxjdbc. @@ -948,7 +948,7 @@ PGBit = BIT class UUID(sqltypes.TypeEngine): - """Postgresql UUID type. + """PostgreSQL UUID type. Represents the UUID column type, interpreting data either as natively returned by the DBAPI @@ -1001,7 +1001,7 @@ PGUuid = UUID class TSVECTOR(sqltypes.TypeEngine): - """The :class:`.postgresql.TSVECTOR` type implements the Postgresql + """The :class:`.postgresql.TSVECTOR` type implements the PostgreSQL text search type TSVECTOR. It can be used to do full text queries on natural language @@ -1019,14 +1019,14 @@ class TSVECTOR(sqltypes.TypeEngine): class ENUM(sqltypes.Enum): - """Postgresql ENUM type. + """PostgreSQL ENUM type. This is a subclass of :class:`.types.Enum` which includes support for PG's ``CREATE TYPE`` and ``DROP TYPE``. When the builtin type :class:`.types.Enum` is used and the :paramref:`.Enum.native_enum` flag is left at its default of - True, the Postgresql backend will use a :class:`.postgresql.ENUM` + True, the PostgreSQL backend will use a :class:`.postgresql.ENUM` type as the implementation, so the special create/drop rules will be used. @@ -1085,7 +1085,7 @@ class ENUM(sqltypes.Enum): my_enum.create(engine) my_enum.drop(engine) - .. versionchanged:: 1.0.0 The Postgresql :class:`.postgresql.ENUM` type + .. versionchanged:: 1.0.0 The PostgreSQL :class:`.postgresql.ENUM` type now behaves more strictly with regards to CREATE/DROP. A metadata-level ENUM type will only be created and dropped at the metadata level, not the table level, with the exception of @@ -1132,7 +1132,7 @@ class ENUM(sqltypes.Enum): :class:`~.postgresql.ENUM`. If the underlying dialect does not support - Postgresql CREATE TYPE, no action is taken. + PostgreSQL CREATE TYPE, no action is taken. :param bind: a connectable :class:`.Engine`, :class:`.Connection`, or similar object to emit @@ -1156,7 +1156,7 @@ class ENUM(sqltypes.Enum): :class:`~.postgresql.ENUM`. If the underlying dialect does not support - Postgresql DROP TYPE, no action is taken. + PostgreSQL DROP TYPE, no action is taken. :param bind: a connectable :class:`.Engine`, :class:`.Connection`, or similar object to emit @@ -1783,7 +1783,7 @@ class PGIdentifierPreparer(compiler.IdentifierPreparer): def format_type(self, type_, use_schema=True): if not type_.name: - raise exc.CompileError("Postgresql ENUM type requires a name.") + raise exc.CompileError("PostgreSQL ENUM type requires a name.") name = self.quote(type_.name) effective_schema = self.schema_for_object(type_) diff --git a/lib/sqlalchemy/dialects/postgresql/dml.py b/lib/sqlalchemy/dialects/postgresql/dml.py index e8e6cd165..3ab124c34 100644 --- a/lib/sqlalchemy/dialects/postgresql/dml.py +++ b/lib/sqlalchemy/dialects/postgresql/dml.py @@ -18,7 +18,7 @@ __all__ = ('Insert', 'insert') class Insert(StandardInsert): - """Postgresql-specific implementation of INSERT. + """PostgreSQL-specific implementation of INSERT. Adds methods for PG-specific syntaxes such as ON CONFLICT. diff --git a/lib/sqlalchemy/dialects/postgresql/ext.py b/lib/sqlalchemy/dialects/postgresql/ext.py index 8a6524f42..a48487679 100644 --- a/lib/sqlalchemy/dialects/postgresql/ext.py +++ b/lib/sqlalchemy/dialects/postgresql/ext.py @@ -13,7 +13,7 @@ from .array import ARRAY class aggregate_order_by(expression.ColumnElement): - """Represent a Postgresql aggregate order by expression. + """Represent a PostgreSQL aggregate order by expression. E.g.:: @@ -157,7 +157,7 @@ static/sql-createtable.html#SQL-CREATETABLE-EXCLUDE def array_agg(*arg, **kw): - """Postgresql-specific form of :class:`.array_agg`, ensures + """PostgreSQL-specific form of :class:`.array_agg`, ensures return type is :class:`.postgresql.ARRAY` and not the plain :class:`.types.ARRAY`. diff --git a/lib/sqlalchemy/dialects/postgresql/hstore.py b/lib/sqlalchemy/dialects/postgresql/hstore.py index d3ff30efb..dc2e20de5 100644 --- a/lib/sqlalchemy/dialects/postgresql/hstore.py +++ b/lib/sqlalchemy/dialects/postgresql/hstore.py @@ -50,7 +50,7 @@ CONTAINED_BY = operators.custom_op( class HSTORE(sqltypes.Indexable, sqltypes.Concatenable, sqltypes.TypeEngine): - """Represent the Postgresql HSTORE type. + """Represent the PostgreSQL HSTORE type. The :class:`.HSTORE` type stores dictionaries containing strings, e.g.:: @@ -117,7 +117,7 @@ class HSTORE(sqltypes.Indexable, sqltypes.Concatenable, sqltypes.TypeEngine): .. seealso:: - :class:`.hstore` - render the Postgresql ``hstore()`` function. + :class:`.hstore` - render the PostgreSQL ``hstore()`` function. """ @@ -254,10 +254,10 @@ ischema_names['hstore'] = HSTORE class hstore(sqlfunc.GenericFunction): """Construct an hstore value within a SQL expression using the - Postgresql ``hstore()`` function. + PostgreSQL ``hstore()`` function. The :class:`.hstore` function accepts one or two arguments as described - in the Postgresql documentation. + in the PostgreSQL documentation. E.g.:: @@ -276,7 +276,7 @@ class hstore(sqlfunc.GenericFunction): .. seealso:: - :class:`.HSTORE` - the Postgresql ``HSTORE`` datatype. + :class:`.HSTORE` - the PostgreSQL ``HSTORE`` datatype. """ type = HSTORE diff --git a/lib/sqlalchemy/dialects/postgresql/json.py b/lib/sqlalchemy/dialects/postgresql/json.py index 821018471..8d09b46be 100644 --- a/lib/sqlalchemy/dialects/postgresql/json.py +++ b/lib/sqlalchemy/dialects/postgresql/json.py @@ -87,16 +87,16 @@ colspecs[sqltypes.JSON.JSONPathType] = JSONPathType class JSON(sqltypes.JSON): - """Represent the Postgresql JSON type. + """Represent the PostgreSQL JSON type. This type is a specialization of the Core-level :class:`.types.JSON` type. Be sure to read the documentation for :class:`.types.JSON` for important tips regarding treatment of NULL values and ORM use. - .. versionchanged:: 1.1 :class:`.postgresql.JSON` is now a Postgresql- + .. versionchanged:: 1.1 :class:`.postgresql.JSON` is now a PostgreSQL- specific specialization of the new :class:`.types.JSON` type. - The operators provided by the Postgresql version of :class:`.JSON` + The operators provided by the PostgreSQL version of :class:`.JSON` include: * Index operations (the ``->`` operator):: @@ -219,7 +219,7 @@ ischema_names['json'] = JSON class JSONB(JSON): - """Represent the Postgresql JSONB type. + """Represent the PostgreSQL JSONB type. The :class:`.JSONB` type stores arbitrary JSONB format data, e.g.:: diff --git a/lib/sqlalchemy/dialects/postgresql/psycopg2.py b/lib/sqlalchemy/dialects/postgresql/psycopg2.py index 417b7654d..8488da816 100644 --- a/lib/sqlalchemy/dialects/postgresql/psycopg2.py +++ b/lib/sqlalchemy/dialects/postgresql/psycopg2.py @@ -126,14 +126,14 @@ on all new connections based on the value passed to :func:`.create_engine` using the ``client_encoding`` parameter:: # set_client_encoding() setting; - # works for *all* Postgresql versions + # works for *all* PostgreSQL versions engine = create_engine("postgresql://user:pass@host/dbname", client_encoding='utf8') -This overrides the encoding specified in the Postgresql client configuration. +This overrides the encoding specified in the PostgreSQL client configuration. When using the parameter in this way, the psycopg2 driver emits ``SET client_encoding TO 'utf8'`` on the connection explicitly, and works -in all Postgresql versions. +in all PostgreSQL versions. Note that the ``client_encoding`` setting as passed to :func:`.create_engine` is **not the same** as the more recently added ``client_encoding`` parameter @@ -142,14 +142,14 @@ is passed directly to ``psycopg2.connect()``, and from SQLAlchemy is passed using the :paramref:`.create_engine.connect_args` parameter:: # libpq direct parameter setting; - # only works for Postgresql **9.1 and above** + # only works for PostgreSQL **9.1 and above** engine = create_engine("postgresql://user:pass@host/dbname", connect_args={'client_encoding': 'utf8'}) # using the query string is equivalent engine = create_engine("postgresql://user:pass@host/dbname?client_encoding=utf8") -The above parameter was only added to libpq as of version 9.1 of Postgresql, +The above parameter was only added to libpq as of version 9.1 of PostgreSQL, so using the previous method is better for cross-version support. .. _psycopg2_disable_native_unicode: @@ -229,12 +229,12 @@ Psycopg2 Transaction Isolation Level ------------------------------------- As discussed in :ref:`postgresql_isolation_level`, -all Postgresql dialects support setting of transaction isolation level +all PostgreSQL dialects support setting of transaction isolation level both via the ``isolation_level`` parameter passed to :func:`.create_engine`, as well as the ``isolation_level`` argument used by :meth:`.Connection.execution_options`. When using the psycopg2 dialect, these options make use of psycopg2's ``set_isolation_level()`` connection method, -rather than emitting a Postgresql directive; this is because psycopg2's +rather than emitting a PostgreSQL directive; this is because psycopg2's API-level setting is always emitted at the start of each transaction in any case. @@ -259,7 +259,7 @@ The psycopg2 dialect supports these constants for isolation level: NOTICE logging --------------- -The psycopg2 dialect will log Postgresql NOTICE messages via the +The psycopg2 dialect will log PostgreSQL NOTICE messages via the ``sqlalchemy.dialects.postgresql`` logger:: import logging diff --git a/lib/sqlalchemy/dialects/postgresql/ranges.py b/lib/sqlalchemy/dialects/postgresql/ranges.py index 42a1cd4b1..9203b43ba 100644 --- a/lib/sqlalchemy/dialects/postgresql/ranges.py +++ b/lib/sqlalchemy/dialects/postgresql/ranges.py @@ -24,7 +24,7 @@ class RangeOperators(object): Table 9-45 of the postgres documentation. For these, the normal :func:`~sqlalchemy.sql.expression.func` object should be used. - .. versionadded:: 0.8.2 Support for Postgresql RANGE operations. + .. versionadded:: 0.8.2 Support for PostgreSQL RANGE operations. """ @@ -97,7 +97,7 @@ class RangeOperators(object): class INT4RANGE(RangeOperators, sqltypes.TypeEngine): - """Represent the Postgresql INT4RANGE type. + """Represent the PostgreSQL INT4RANGE type. .. versionadded:: 0.8.2 @@ -109,7 +109,7 @@ ischema_names['int4range'] = INT4RANGE class INT8RANGE(RangeOperators, sqltypes.TypeEngine): - """Represent the Postgresql INT8RANGE type. + """Represent the PostgreSQL INT8RANGE type. .. versionadded:: 0.8.2 @@ -121,7 +121,7 @@ ischema_names['int8range'] = INT8RANGE class NUMRANGE(RangeOperators, sqltypes.TypeEngine): - """Represent the Postgresql NUMRANGE type. + """Represent the PostgreSQL NUMRANGE type. .. versionadded:: 0.8.2 @@ -133,7 +133,7 @@ ischema_names['numrange'] = NUMRANGE class DATERANGE(RangeOperators, sqltypes.TypeEngine): - """Represent the Postgresql DATERANGE type. + """Represent the PostgreSQL DATERANGE type. .. versionadded:: 0.8.2 @@ -145,7 +145,7 @@ ischema_names['daterange'] = DATERANGE class TSRANGE(RangeOperators, sqltypes.TypeEngine): - """Represent the Postgresql TSRANGE type. + """Represent the PostgreSQL TSRANGE type. .. versionadded:: 0.8.2 @@ -157,7 +157,7 @@ ischema_names['tsrange'] = TSRANGE class TSTZRANGE(RangeOperators, sqltypes.TypeEngine): - """Represent the Postgresql TSTZRANGE type. + """Represent the PostgreSQL TSTZRANGE type. .. versionadded:: 0.8.2 diff --git a/lib/sqlalchemy/dialects/type_migration_guidelines.txt b/lib/sqlalchemy/dialects/type_migration_guidelines.txt index 2d06cf697..e6be2056c 100644 --- a/lib/sqlalchemy/dialects/type_migration_guidelines.txt +++ b/lib/sqlalchemy/dialects/type_migration_guidelines.txt @@ -85,9 +85,9 @@ Example 4. MySQL has a SET type, there's no analogue for this in types.py. So MySQL names it SET in the dialect's base.py, and it subclasses types.String, since it ultimately deals with strings. -Example 5. Postgresql has a DATETIME type. The DBAPIs handle dates correctly, +Example 5. PostgreSQL has a DATETIME type. The DBAPIs handle dates correctly, and no special arguments are used in PG's DDL beyond what types.py provides. -Postgresql dialect therefore imports types.DATETIME into its base.py. +PostgreSQL dialect therefore imports types.DATETIME into its base.py. Ideally one should be able to specify a schema using names imported completely from a dialect, all matching the real name on that backend: diff --git a/lib/sqlalchemy/engine/__init__.py b/lib/sqlalchemy/engine/__init__.py index 6d092e15c..843e68f0f 100644 --- a/lib/sqlalchemy/engine/__init__.py +++ b/lib/sqlalchemy/engine/__init__.py @@ -246,7 +246,7 @@ def create_engine(*args, **kwargs): fetch newly generated primary key values when a single row INSERT statement is emitted with no existing returning() clause. This applies to those backends which support RETURNING - or a compatible construct, including Postgresql, Firebird, Oracle, + or a compatible construct, including PostgreSQL, Firebird, Oracle, Microsoft SQL Server. Set this to ``False`` to disable the automatic usage of RETURNING. @@ -272,7 +272,7 @@ def create_engine(*args, **kwargs): :ref:`SQLite Transaction Isolation <sqlite_isolation_level>` - :ref:`Postgresql Transaction Isolation <postgresql_isolation_level>` + :ref:`PostgreSQL Transaction Isolation <postgresql_isolation_level>` :ref:`MySQL Transaction Isolation <mysql_isolation_level>` diff --git a/lib/sqlalchemy/engine/base.py b/lib/sqlalchemy/engine/base.py index f107578b2..1d23c66b3 100644 --- a/lib/sqlalchemy/engine/base.py +++ b/lib/sqlalchemy/engine/base.py @@ -269,7 +269,7 @@ class Connection(Connectable): :ref:`SQLite Transaction Isolation <sqlite_isolation_level>` - :ref:`Postgresql Transaction Isolation <postgresql_isolation_level>` + :ref:`PostgreSQL Transaction Isolation <postgresql_isolation_level>` :ref:`MySQL Transaction Isolation <mysql_isolation_level>` diff --git a/lib/sqlalchemy/engine/default.py b/lib/sqlalchemy/engine/default.py index 05a993918..3ee240383 100644 --- a/lib/sqlalchemy/engine/default.py +++ b/lib/sqlalchemy/engine/default.py @@ -124,7 +124,7 @@ class DefaultDialect(interfaces.Dialect): }) ] - If the above construct is established on the Postgresql dialect, + If the above construct is established on the PostgreSQL dialect, the :class:`.Index` construct will now accept the keyword arguments ``postgresql_using``, ``postgresql_where``, nad ``postgresql_ops``. Any other argument specified to the constructor of :class:`.Index` diff --git a/lib/sqlalchemy/engine/interfaces.py b/lib/sqlalchemy/engine/interfaces.py index 2560937ab..d64e47fee 100644 --- a/lib/sqlalchemy/engine/interfaces.py +++ b/lib/sqlalchemy/engine/interfaces.py @@ -100,7 +100,7 @@ class Dialect(object): preexecute_autoincrement_sequences True if 'implicit' primary key functions must be executed separately in order to get their value. This is currently oriented towards - Postgresql. + PostgreSQL. implicit_returning use RETURNING or equivalent during INSERT execution in order to load @@ -136,7 +136,7 @@ class Dialect(object): sequences_optional If True, indicates if the "optional" flag on the Sequence() construct should signal to not generate a CREATE SEQUENCE. Applies only to - dialects that support sequences. Currently used only to allow Postgresql + dialects that support sequences. Currently used only to allow PostgreSQL SERIAL to be used on a column that specifies Sequence() for usage on other backends. diff --git a/lib/sqlalchemy/engine/reflection.py b/lib/sqlalchemy/engine/reflection.py index 14e98cecf..5d11bf990 100644 --- a/lib/sqlalchemy/engine/reflection.py +++ b/lib/sqlalchemy/engine/reflection.py @@ -143,7 +143,7 @@ class Inspector(object): """Return the default schema name presented by the dialect for the current engine's database user. - E.g. this is typically ``public`` for Postgresql and ``dbo`` + E.g. this is typically ``public`` for PostgreSQL and ``dbo`` for SQL Server. """ diff --git a/lib/sqlalchemy/ext/compiler.py b/lib/sqlalchemy/ext/compiler.py index 5ef4e1d2a..20cca885e 100644 --- a/lib/sqlalchemy/ext/compiler.py +++ b/lib/sqlalchemy/ext/compiler.py @@ -299,7 +299,7 @@ savings ends, without timezones because timezones are like character encodings - they're best applied only at the endpoints of an application (i.e. convert to UTC upon user input, re-apply desired timezone upon display). -For Postgresql and Microsoft SQL Server:: +For PostgreSQL and Microsoft SQL Server:: from sqlalchemy.sql import expression from sqlalchemy.ext.compiler import compiles diff --git a/lib/sqlalchemy/ext/indexable.py b/lib/sqlalchemy/ext/indexable.py index 52a502ae4..6d00e2eed 100644 --- a/lib/sqlalchemy/ext/indexable.py +++ b/lib/sqlalchemy/ext/indexable.py @@ -143,7 +143,7 @@ Above, a query such as:: q = session.query(Person).filter(Person.year == '1980') -On a Postgresql backend, the above query will render as:: +On a PostgreSQL backend, the above query will render as:: SELECT person.id, person.data FROM person @@ -183,7 +183,7 @@ Subclassing :class:`.index_property` can be subclassed, in particular for the common use case of providing coercion of values or SQL expressions as they are -accessed. Below is a common recipe for use with a Postgresql JSON type, +accessed. Below is a common recipe for use with a PostgreSQL JSON type, where we want to also include automatic casting plus ``astext()``:: class pg_json_property(index_property): @@ -195,7 +195,7 @@ where we want to also include automatic casting plus ``astext()``:: expr = super(pg_json_property, self).expr(model) return expr.astext.cast(self.cast_type) -The above subclass can be used with the Postgresql-specific +The above subclass can be used with the PostgreSQL-specific version of :class:`.postgresql.JSON`:: from sqlalchemy import Column, Integer @@ -213,7 +213,7 @@ version of :class:`.postgresql.JSON`:: age = pg_json_property('data', 'age', Integer) The ``age`` attribute at the instance level works as before; however -when rendering SQL, Postgresql's ``->>`` operator will be used +when rendering SQL, PostgreSQL's ``->>`` operator will be used for indexed access, instead of the usual index opearator of ``->``:: >>> query = session.query(Person).filter(Person.age < 20) diff --git a/lib/sqlalchemy/orm/query.py b/lib/sqlalchemy/orm/query.py index e6416d173..d6a81ffd6 100644 --- a/lib/sqlalchemy/orm/query.py +++ b/lib/sqlalchemy/orm/query.py @@ -480,7 +480,7 @@ class Query(object): :meth:`.SelectBase.cte` method; see that method for further details. - Here is the `Postgresql WITH + Here is the `PostgreSQL WITH RECURSIVE example <http://www.postgresql.org/docs/8.4/static/queries-with.html>`_. Note that, in this example, the ``included_parts`` cte and the @@ -1413,7 +1413,7 @@ class Query(object): q = sess.query(User).with_for_update(nowait=True, of=User) - The above query on a Postgresql backend will render like:: + The above query on a PostgreSQL backend will render like:: SELECT users.id AS users_id FROM users FOR UPDATE OF users NOWAIT @@ -2568,7 +2568,7 @@ class Query(object): :attr:`.Query.statement` accessor, however. :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/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 diff --git a/lib/sqlalchemy/testing/requirements.py b/lib/sqlalchemy/testing/requirements.py index b0f466892..af148a3b9 100644 --- a/lib/sqlalchemy/testing/requirements.py +++ b/lib/sqlalchemy/testing/requirements.py @@ -652,7 +652,7 @@ class SuiteRequirements(Requirements): select data as foo from test order by foo || 'bar' - Lots of databases including Postgresql don't support this, + Lots of databases including PostgreSQL don't support this, so this is off by default. """ @@ -752,7 +752,7 @@ class SuiteRequirements(Requirements): """Test should be skipped if coverage is enabled. This is to block tests that exercise libraries that seem to be - sensitive to coverage, such as Postgresql notice logging. + sensitive to coverage, such as PostgreSQL notice logging. """ return exclusions.skip_if( diff --git a/lib/sqlalchemy/testing/suite/test_results.py b/lib/sqlalchemy/testing/suite/test_results.py index 9ffaa6e04..f40d9a04c 100644 --- a/lib/sqlalchemy/testing/suite/test_results.py +++ b/lib/sqlalchemy/testing/suite/test_results.py @@ -111,7 +111,7 @@ class PercentSchemaNamesTest(fixtures.TablesTest): """tests using percent signs, spaces in table and column names. This is a very fringe use case, doesn't work for MySQL - or Postgresql. the requirement, "percent_schema_names", + or PostgreSQL. the requirement, "percent_schema_names", is marked "skip" by default. """ |