Warn in the documentation that some features are native in newer Django versions

Author: Photonios

README.md

@@ -31,30 +31,35 @@ With seamless we mean that any features we add will work truly seamlessly. You s
 
 [See the full list](http://django-postgres-extra.readthedocs.io/#features)
 
-* **Native upserts**
+* **Conflict handling (atomic upsert)**
 
-    * Single query
-    * Concurrency safe
-    * With bulk support (single query)
+    Add support for PostgreSQL's `ON CONFLICT` syntax for inserts. Supports `DO UPDATE` and `DO NOTHING`. Single statement, atomic and concurrency safe upserts. Supports conditional updates as well.
 
-* **Extended support for HStoreField**
+* **Table partitioning**
 
-    * Unique constraints
-    * Null constraints
-    * Select individual keys using ``.values()`` or ``.values_list()``
+    Add support for PostgreSQL 11.x declarative table partitioning. Fully integrated into Django migrations. Supports all types of partitioning. Includes a command to automatically create time-based partitions.
 
-* **PostgreSQL 11.x declarative table partitioning**
+* **Locking models & tables**
 
-    * Supports both range and list partitioning
+    Support for explicit table-level locks.
 
-* **Faster deletes**
+* **Creating/dropping schemas**
 
-    * Truncate tables (with cascade)
+    Support for managing PostgreSQL schemas.
 
-* **Indexes**
+* **Truncating tables**
 
-    * Conditional unique index.
-    * Case sensitive unique index.
+   Support for ``TRUNCATE TABLE`` statements (including cascading).
+
+For Django 3.1 and older:
+
+* **Conditional unique index**
+* **Case insensitive index**
+
+For Django 2.2 and older:
+
+* **Unique index**
+* **HStore unique and required constraints on specific HStore keys**
 
 ## Working with the code
 ### Prerequisites

docs/source/hstore.rst

@@ -15,6 +15,10 @@ Constraints
 Unique
 ******
 
+.. warning::
+
+    In Django 2.2 or newer, you might want to use :class:`~django.db.models.UniqueConstraint` instead.
+
 The ``uniqueness`` constraint can be added on one or more `hstore`_ keys, similar to how a ``UNIQUE`` constraint can be added to a column. Setting this option causes unique indexes to be created on the specified keys.
 
 You can specify a ``list`` of strings to specify the keys that must be marked as unique:
@@ -44,6 +48,10 @@ In the example above, ``key1`` and ``key2`` must unique **together**, and ``key3
 Required
 ********
 
+.. warning::
+
+    In Django 2.2 or newer, you might want to use :class:`~django.db.models.CheckConstraint` instead.
+
 The ``required`` option can be added to ensure that the specified `hstore`_ keys are set for every row. This is similar to a ``NOT NULL`` constraint on a column. You can specify a list of `hstore`_ keys that are required:
 
 .. code-block:: python

docs/source/index.rst

@@ -13,36 +13,43 @@ Explore the documentation to learn about all features:
 
 * :ref:`Conflict handling <conflict_handling_page>`
 
-    Adds support for PostgreSQL's ``ON CONFLICT`` syntax for inserts. Supports for ``DO UPDATE`` and ``DO NOTHING``. In other words; single statement, atomic, concurrency safe upserts.
+    Adds support for PostgreSQL's ``ON CONFLICT`` syntax for inserts. Supports for ``DO UPDATE`` and ``DO NOTHING``. Single statement, atomic, concurrency safe upserts. Supports conditional updates as well.
 
-* :ref:`HStore <hstore_page>`
-
-    Built on top Django's built-in support for `hstore`_ fields. Adds support for indices on keys and unique/required constraints. All of these features integrate well with Django's migrations sytem.
+* :ref:`Table partitioning <table_partitioning_page>`
 
-* :ref:`Partial unique index <conditional_unique_index_page>`
+    Add support for PostgreSQL 11.x declarative table partitioning. Fully integrated into Django migrations. Supports all types of partitioning. Includes a command to automatically create time-based partitions.
 
-   Partial (unique) index that only applies when a certain condition is true.
-
-* :ref:`Case insensitive index <case_insensitive_unique_index_page>`
+* :ref:`Locking models & tables <locking_page>`
 
-   Case insensitive index, allows searching a column and ignoring the casing.
+   Support for explicit table-level locks.
 
-* :ref:`Table partitioning <table_partitioning_page>`
+* :ref:`Creating/dropping schemas <schemas_page>`
 
-    Adds support for PostgreSQL 11.x declarative table partitioning.
+    Support for managing Postgres schemas.
 
 * :ref:`Truncating tables <truncate_page>`
 
    Support for ``TRUNCATE TABLE`` statements (including cascading).
 
-* :ref:`Locking models & tables <locking_page>`
+For Django 3.1 and older:
 
-   Support for explicit table-level locks.
+* :ref:`Partial unique index <conditional_unique_index_page>`
 
+   Partial (unique) index that only applies when a certain condition is true.
 
-* :ref:`Creating/dropping schemas <schemas_page>`
+* :ref:`Case insensitive index <case_insensitive_unique_index_page>`
 
-    Support for managing Postgres schemas.
+   Case insensitive index, allows searching a column and ignoring the casing.
+
+For Django 2.2 and older:
+
+* :ref:`Unique index <unique_index_page>`
+
+   Unique indices that can span more than one field.
+
+* :ref:`HStore key unique & required constraint <hstore_page>`
+
+   Add unique and required constraints in specific hstore keys.
 
 
 .. toctree::

docs/source/indexes.rst

@@ -7,6 +7,11 @@ Indexes
 
 Unique Index
 -----------------------------
+
+.. warning::
+
+    In Django 2.2 or newer, you might want to use :class:`~django.db.models.UniqueConstraint` instead.
+
 The :class:`~psqlextra.indexes.UniqueIndex` lets you create a unique index. Normally Django only allows you to create unique indexes by specifying ``unique=True`` on the model field.
 
 Although it can be used on any Django model, it is most useful on views and materialized views where ``unique=True`` does not work.
@@ -32,13 +37,14 @@ Although it can be used on any Django model, it is most useful on views and mate
 
 Conditional Unique Index
 ------------------------
-The :class:`~psqlextra.indexes.ConditionalUniqueIndex` lets you create partial unique indexes in case you ever need :attr:`~django:django.db.models.Options.unique_together` constraints
-on nullable columns.
 
 .. warning::
 
     In Django 3.1 or newer, you might want to use :attr:`~django.db.models.indexes.condition` instead.
 
+The :class:`~psqlextra.indexes.ConditionalUniqueIndex` lets you create partial unique indexes in case you ever need :attr:`~django:django.db.models.Options.unique_together` constraints
+on nullable columns.
+
 Before:
 
 .. code-block:: python
@@ -83,6 +89,11 @@ After:
 
 Case Insensitive Unique Index
 -----------------------------
+
+.. warning::
+
+    In Django 3.1 or newer, you might want to use :attr:`~django.db.models.indexes.condition` instead.
+
 The :class:`~psqlextra.indexes.CaseInsensitiveUniqueIndex` lets you create an index that ignores the casing for the specified field(s).
 
 This makes the field(s) behave more like a text field in MySQL.