1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
|
=====================
Model index reference
=====================
.. module:: django.db.models.indexes
.. currentmodule:: django.db.models
Index classes ease creating database indexes. They can be added using the
:attr:`Meta.indexes <django.db.models.Options.indexes>` option. This document
explains the API references of :class:`Index` which includes the `index
options`_.
.. admonition:: Referencing built-in indexes
Indexes are defined in ``django.db.models.indexes``, but for convenience
they're imported into :mod:`django.db.models`. The standard convention is
to use ``from django.db import models`` and refer to the indexes as
``models.<IndexClass>``.
``Index`` options
=================
.. class:: Index(*expressions, fields=(), name=None, db_tablespace=None, opclasses=(), condition=None, include=None)
Creates an index (B-Tree) in the database.
``expressions``
---------------
.. attribute:: Index.expressions
Positional argument ``*expressions`` allows creating functional indexes on
expressions and database functions.
For example::
Index(Lower("title").desc(), "pub_date", name="lower_title_date_idx")
creates an index on the lowercased value of the ``title`` field in descending
order and the ``pub_date`` field in the default ascending order.
Another example::
Index(F("height") * F("weight"), Round("weight"), name="calc_idx")
creates an index on the result of multiplying fields ``height`` and ``weight``
and the ``weight`` rounded to the nearest integer.
:attr:`Index.name` is required when using ``*expressions``.
.. admonition:: Restrictions on Oracle
Oracle requires functions referenced in an index to be marked as
``DETERMINISTIC``. Django doesn't validate this but Oracle will error. This
means that functions such as
:class:`Random() <django.db.models.functions.Random>` aren't accepted.
.. admonition:: Restrictions on PostgreSQL
PostgreSQL requires functions and operators referenced in an index to be
marked as ``IMMUTABLE``. Django doesn't validate this but PostgreSQL will
error. This means that functions such as
:class:`Concat() <django.db.models.functions.Concat>` aren't accepted.
.. admonition:: MySQL and MariaDB
Functional indexes are ignored with MySQL < 8.0.13 and MariaDB as neither
supports them.
``fields``
----------
.. attribute:: Index.fields
A list or tuple of the name of the fields on which the index is desired.
By default, indexes are created with an ascending order for each column. To
define an index with a descending order for a column, add a hyphen before the
field's name.
For example ``Index(fields=['headline', '-pub_date'])`` would create SQL with
``(headline, pub_date DESC)``.
.. admonition:: MySQL and MariaDB
Index ordering isn't supported on MySQL < 8.0.1 and MariaDB < 10.8. In that
case, a descending index is created as a normal index.
``name``
--------
.. attribute:: Index.name
The name of the index. If ``name`` isn't provided Django will auto-generate a
name. For compatibility with different databases, index names cannot be longer
than 30 characters and shouldn't start with a number (0-9) or underscore (_).
.. admonition:: Partial indexes in abstract base classes
You must always specify a unique name for an index. As such, you
cannot normally specify a partial index on an abstract base class, since
the :attr:`Meta.indexes <django.db.models.Options.indexes>` option is
inherited by subclasses, with exactly the same values for the attributes
(including ``name``) each time. To work around name collisions, part of the
name may contain ``'%(app_label)s'`` and ``'%(class)s'``, which are
replaced, respectively, by the lowercased app label and class name of the
concrete model. For example ``Index(fields=['title'],
name='%(app_label)s_%(class)s_title_index')``.
``db_tablespace``
-----------------
.. attribute:: Index.db_tablespace
The name of the :doc:`database tablespace </topics/db/tablespaces>` to use for
this index. For single field indexes, if ``db_tablespace`` isn't provided, the
index is created in the ``db_tablespace`` of the field.
If :attr:`.Field.db_tablespace` isn't specified (or if the index uses multiple
fields), the index is created in tablespace specified in the
:attr:`~django.db.models.Options.db_tablespace` option inside the model's
``class Meta``. If neither of those tablespaces are set, the index is created
in the same tablespace as the table.
.. seealso::
For a list of PostgreSQL-specific indexes, see
:mod:`django.contrib.postgres.indexes`.
``opclasses``
-------------
.. attribute:: Index.opclasses
The names of the `PostgreSQL operator classes
<https://www.postgresql.org/docs/current/indexes-opclass.html>`_ to use for
this index. If you require a custom operator class, you must provide one for
each field in the index.
For example, ``GinIndex(name='json_index', fields=['jsonfield'],
opclasses=['jsonb_path_ops'])`` creates a gin index on ``jsonfield`` using
``jsonb_path_ops``.
``opclasses`` are ignored for databases besides PostgreSQL.
:attr:`Index.name` is required when using ``opclasses``.
``condition``
-------------
.. attribute:: Index.condition
If the table is very large and your queries mostly target a subset of rows,
it may be useful to restrict an index to that subset. Specify a condition as a
:class:`~django.db.models.Q`. For example, ``condition=Q(pages__gt=400)``
indexes records with more than 400 pages.
:attr:`Index.name` is required when using ``condition``.
.. admonition:: Restrictions on PostgreSQL
PostgreSQL requires functions referenced in the condition to be marked as
IMMUTABLE. Django doesn't validate this but PostgreSQL will error. This
means that functions such as :ref:`date-functions` and
:class:`~django.db.models.functions.Concat` aren't accepted. If you store
dates in :class:`~django.db.models.DateTimeField`, comparison to
:class:`~datetime.datetime` objects may require the ``tzinfo`` argument
to be provided because otherwise the comparison could result in a mutable
function due to the casting Django does for :ref:`lookups <field-lookups>`.
.. admonition:: Restrictions on SQLite
SQLite `imposes restrictions <https://www.sqlite.org/partialindex.html>`_
on how a partial index can be constructed.
.. admonition:: Oracle
Oracle does not support partial indexes. Instead, partial indexes can be
emulated by using functional indexes together with
:class:`~django.db.models.expressions.Case` expressions.
.. admonition:: MySQL and MariaDB
The ``condition`` argument is ignored with MySQL and MariaDB as neither
supports conditional indexes.
``include``
-----------
.. attribute:: Index.include
A list or tuple of the names of the fields to be included in the covering index
as non-key columns. This allows index-only scans to be used for queries that
select only included fields (:attr:`~Index.include`) and filter only by indexed
fields (:attr:`~Index.fields`).
For example::
Index(name="covering_index", fields=["headline"], include=["pub_date"])
will allow filtering on ``headline``, also selecting ``pub_date``, while
fetching data only from the index.
Using ``include`` will produce a smaller index than using a multiple column
index but with the drawback that non-key columns can not be used for sorting or
filtering.
``include`` is ignored for databases besides PostgreSQL.
:attr:`Index.name` is required when using ``include``.
See the PostgreSQL documentation for more details about `covering indexes`_.
.. admonition:: Restrictions on PostgreSQL
PostgreSQL supports covering B-Tree and :class:`GiST indexes
<django.contrib.postgres.indexes.GistIndex>`. PostgreSQL 14+ also supports
covering :class:`SP-GiST indexes
<django.contrib.postgres.indexes.SpGistIndex>`.
.. _covering indexes: https://www.postgresql.org/docs/current/indexes-index-only-scans.html
|
