所有这些字段都可以从 django.contrib.postgres.field 模块中获得。
Index 和 Field.db_index 都创建了一个 B 树索引，在查询复杂的数据类型时并不是特别有用。像 GinIndex 和 GistIndex 这样的索引比较适合，不过索引的选择取决于你使用的查询。一般来说，GiST 可能是 range 字段 和 HStoreField 的好选择，而 GIN 可能对 ArrayField 有帮助。
ArrayFieldLink to this heading#一个用于存储数据列表的字段。大多数字段类型都可以使用，你可以通过另一个字段实例作为 base_field。你也可以指定一个 size。ArrayField 可以嵌套来存储多维数组。
如果你给字段一个 default，确保它是一个可调用对象，比如 list （对于一个空的默认值），或者一个返回一个列表的可调用对象（比如一个函数）。错误地使用 default=[] 会创建一个可变的默认值，这个默认值在 ArrayField 的所有实例之间共享。
这是一个必要的参数。
\n指定数组的底层数据类型和行为。它应该是 Field 子类的实例。例如，它可以是一个 IntegerField 或一个 CharField。大多数字段类型都是允许的，但不包括处理关系数据的字段（ForeignKey、OneToOneField 和 ManyToManyField）以及文件字段（FileField 和 ImageField）。
可以嵌套数组字段——你可以指定一个 ArrayField 的实例作为 base_field。例如：
from django.contrib.postgres.fields import ArrayField\nfrom django.db import models\n\n\nclass ChessBoard(models.Model):\n board = ArrayField(\n ArrayField(\n models.CharField(max_length=10, blank=True),\n size=8,\n ),\n size=8,\n )\n数据库和模型之间的值的转换、数据和配置的验证以及序列化都是委托给底层基础字段的。
\n这是一个可选的参数。
\n如果传入，数组将有一个指定的最大大小。这将被传递给数据库，尽管 PostgreSQL 目前并没有强制执行这个限制。
\nArrayFieldLink to this heading#ArrayField 有许多自定义的查找和转换。我们将使用下面的示例模型：
from django.contrib.postgres.fields import ArrayField\nfrom django.db import models\n\n\nclass Post(models.Model):\n name = models.CharField(max_length=200)\n tags = ArrayField(models.CharField(max_length=200), blank=True)\n\n def __str__(self):\n return self.name\ncontainsLink to this heading#ArrayField 上重写了 contains 查询。返回的对象将是那些传递的值是数据的子集的对象。它使用 SQL 运算符 @>。例如：
>>> Post.objects.create(name="First post", tags=["thoughts", "django"])\n>>> Post.objects.create(name="Second post", tags=["thoughts"])\n>>> Post.objects.create(name="Third post", tags=["tutorial", "django"])\n\n>>> Post.objects.filter(tags__contains=["thoughts"])\n<QuerySet [<Post: First post>, <Post: Second post>]>\n\n>>> Post.objects.filter(tags__contains=["django"])\n<QuerySet [<Post: First post>, <Post: Third post>]>\n\n>>> Post.objects.filter(tags__contains=["django", "thoughts"])\n<QuerySet [<Post: First post>]>\ncontained_byLink to this heading#这是 contains 查询的反向操作 - 返回的对象将是那些数据是传递的值的子集的对象。它使用 SQL 运算符 <@。例如：
>>> Post.objects.create(name="First post", tags=["thoughts", "django"])\n>>> Post.objects.create(name="Second post", tags=["thoughts"])\n>>> Post.objects.create(name="Third post", tags=["tutorial", "django"])\n\n>>> Post.objects.filter(tags__contained_by=["thoughts", "django"])\n<QuerySet [<Post: First post>, <Post: Second post>]>\n\n>>> Post.objects.filter(tags__contained_by=["thoughts", "django", "tutorial"])\n<QuerySet [<Post: First post>, <Post: Second post>, <Post: Third post>]>\noverlapLink to this heading#返回数据与传递的值共享任何结果的对象。使用 SQL 运算符 &&。例如：
>>> Post.objects.create(name="First post", tags=["thoughts", "django"])\n>>> Post.objects.create(name="Second post", tags=["thoughts", "tutorial"])\n>>> Post.objects.create(name="Third post", tags=["tutorial", "django"])\n\n>>> Post.objects.filter(tags__overlap=["thoughts"])\n<QuerySet [<Post: First post>, <Post: Second post>]>\n\n>>> Post.objects.filter(tags__overlap=["thoughts", "tutorial"])\n<QuerySet [<Post: First post>, <Post: Second post>, <Post: Third post>]>\n\n>>> Post.objects.filter(tags__overlap=Post.objects.values_list("tags"))\n<QuerySet [<Post: First post>, <Post: Second post>, <Post: Third post>]>\nlenLink to this heading#返回数组的长度。之后可用的查询与 IntegerField 相同。例如：
>>> Post.objects.create(name="First post", tags=["thoughts", "django"])\n>>> Post.objects.create(name="Second post", tags=["thoughts"])\n\n>>> Post.objects.filter(tags__len=1)\n<QuerySet [<Post: Second post>]>\nIndex 转换将索引转换为数组。可以使用任何非负整数。如果超过数组的 size，则不会出现错误。转换后可用的查询是来自 base_field 的查询。例如：
>>> Post.objects.create(name="First post", tags=["thoughts", "django"])\n>>> Post.objects.create(name="Second post", tags=["thoughts"])\n\n>>> Post.objects.filter(tags__0="thoughts")\n<QuerySet [<Post: First post>, <Post: Second post>]>\n\n>>> Post.objects.filter(tags__1__iexact="Django")\n<QuerySet [<Post: First post>]>\n\n>>> Post.objects.filter(tags__276="javascript")\n<QuerySet []>\nSlice 转换获取数组的一个切片。可以使用两个非负整数，用一个下划线分隔。转换后可用的查询不会改变。例如：
\n>>> Post.objects.create(name="First post", tags=["thoughts", "django"])\n>>> Post.objects.create(name="Second post", tags=["thoughts"])\n>>> Post.objects.create(name="Third post", tags=["django", "python", "thoughts"])\n\n>>> Post.objects.filter(tags__0_1=["thoughts"])\n<QuerySet [<Post: First post>, <Post: Second post>]>\n\n>>> Post.objects.filter(tags__0_2__contains=["thoughts"])\n<QuerySet [<Post: First post>, <Post: Second post>]>\nCIText 字段Link to this heading#一个用于创建由 citext 类型支持的不区分大小写的文本字段的混入。在使用它之前，请阅读 性能考虑因素 。
\n要使用 citext，使用 CITextExtension ` 操作，在第一次 ``CreateModel` 迁移操作之前，在 PostgreSQL 中 安装 citext 扩展。
如果你使用的是 ArrayField 的 CIText 字段，你必须在你的 INSTALLED_APPS 中添加 'django.contrib.postgres'，否则字段值会以字符串形式出现，比如 '{thoughts,django}'。
提供了几个使用混入的字段：
\n这些字段分别是 CharField、EmailField 和 TextField 的子类。
max_length 不会在数据库中强制执行，因为 citext 与 PostgreSQL 的 text 类型相似。
HStoreFieldLink to this heading#一个用于存储键值对的字段。使用的 Python 数据类型是 dict。键必须是字符串，值可以是字符串或空值（Python 中的 None）。
要使用该字段，你需要：
\n在你的 INSTALLED_APPS 中增加 'django.contrib.postgres'。
在 PostgreSQL 中 安装 hstore 扩展。
如果你跳过第一步，你会看到一个错误，比如 can't adapt type 'dict'，如果你跳过第二步，你会看到 type "hstore" does not exist。
HStoreFieldLink to this heading#除了按键查询的功能外，HStoreField 还有一些自定义查询功能。
我们将使用以下示例模型：
\nfrom django.contrib.postgres.fields import HStoreField\nfrom django.db import models\n\n\nclass Dog(models.Model):\n name = models.CharField(max_length=200)\n data = HStoreField()\n\n def __str__(self):\n return self.name\n要根据给定的键查询，您可以将该键用作查找名称：
\n>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})\n>>> Dog.objects.create(name="Meg", data={"breed": "collie"})\n\n>>> Dog.objects.filter(data__breed="collie")\n<QuerySet [<Dog: Meg>]>\n您可以在键查找后链接其他查询：
\n>>> Dog.objects.filter(data__breed__contains="l")\n<QuerySet [<Dog: Rufus>, <Dog: Meg>]>\n或者使用 F() 表达式来注释一个键值。例如：
>>> from django.db.models import F\n>>> rufus = Dog.objects.annotate(breed=F("data__breed"))[0]\n>>> rufus.breed\n'labrador'\n如果你想查询的键与另一个查找的名称冲突，你需要使用 hstorefield.contains 查找来代替。
containsLink to this heading#HStoreField 上重写了 contains 查询。返回的对象是那些给定的键值对字典都包含在字段中的对象。它使用 SQL 运算符 @>。例如：
>>> Dog.objects.create(name="Rufus", data={"breed": "labrador", "owner": "Bob"})\n>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})\n>>> Dog.objects.create(name="Fred", data={})\n\n>>> Dog.objects.filter(data__contains={"owner": "Bob"})\n<QuerySet [<Dog: Rufus>, <Dog: Meg>]>\n\n>>> Dog.objects.filter(data__contains={"breed": "collie"})\n<QuerySet [<Dog: Meg>]>\ncontained_byLink to this heading#这是 contains 查询的反向操作 - 返回的对象将是那些对象的键值对是传递值中的子集。它使用 SQL 运算符 <@。例如：
>>> Dog.objects.create(name="Rufus", data={"breed": "labrador", "owner": "Bob"})\n>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})\n>>> Dog.objects.create(name="Fred", data={})\n\n>>> Dog.objects.filter(data__contained_by={"breed": "collie", "owner": "Bob"})\n<QuerySet [<Dog: Meg>, <Dog: Fred>]>\n\n>>> Dog.objects.filter(data__contained_by={"breed": "collie"})\n<QuerySet [<Dog: Fred>]>\nhas_keyLink to this heading#返回包含给定键的数据的对象。使用 SQL 运算符 ?。例如：
>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})\n>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})\n\n>>> Dog.objects.filter(data__has_key="owner")\n<QuerySet [<Dog: Meg>]>\nhas_any_keysLink to this heading#返回其中任何给定键存在于数据中的对象。使用 SQL 运算符 ?|。例如：
>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})\n>>> Dog.objects.create(name="Meg", data={"owner": "Bob"})\n>>> Dog.objects.create(name="Fred", data={})\n\n>>> Dog.objects.filter(data__has_any_keys=["owner", "breed"])\n<QuerySet [<Dog: Rufus>, <Dog: Meg>]>\nhas_keysLink to this heading#返回其中所有给定键都存在于数据中的对象。使用 SQL 运算符 ?&。例如：
>>> Dog.objects.create(name="Rufus", data={})\n>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})\n\n>>> Dog.objects.filter(data__has_keys=["breed", "owner"])\n<QuerySet [<Dog: Meg>]>\nkeysLink to this heading#返回键数组与给定值相等的对象。请注意，顺序不能保证可靠，因此此转换主要用于与 ArrayField 上的查找一起使用。使用 SQL 函数 akeys()。例如：
>>> Dog.objects.create(name="Rufus", data={"toy": "bone"})\n>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})\n\n>>> Dog.objects.filter(data__keys__overlap=["breed", "toy"])\n<QuerySet [<Dog: Rufus>, <Dog: Meg>]>\nvaluesLink to this heading#返回值数组与给定值相等的对象。请注意，顺序不能保证可靠，因此此转换主要用于与 ArrayField 上的查找一起使用。使用 SQL 函数 avals()。例如：
>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})\n>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})\n\n>>> Dog.objects.filter(data__values__contains=["collie"])\n<QuerySet [<Dog: Meg>]>\n有五种范围字段类型，对应 PostgreSQL 中内置的范围类型。这些字段用来存储一个范围的值，例如一个事件的开始和结束时间戳，或者一个活动适合的年龄范围。
\n所有的范围字段在 Python 中都会翻译成 psycopg Range 对象，但如果不需要边界信息，也可以接受元组作为输入。默认是包含下界，不包含上界，即 [) （有关 不同边界 的详细信息，请参阅 PostgreSQL 文档）。对于非离散范围字段（例如 DateTimeRangeField 和 DecimalRangeField），可以使用 default_bounds 参数更改默认边界。
IntegerRangeFieldLink to this heading#存储一组整数范围。基于 IntegerField。在数据库中由 int4range 表示，在 Python 中由 django.db.backends.postgresql.psycopg_any.NumericRange 表示。
无论在保存数据时指定的边界是什么，PostgreSQL 总是以规范的形式返回一个包括下限和排除上限的范围，即 [)。
BigIntegerRangeFieldLink to this heading#存储一组大整数范围。基于 BigIntegerField。在数据库中由 int8range 表示，在 Python 中由 django.db.backends.postgresql.psycopg_any.NumericRange 表示。
无论在保存数据时指定的边界是什么，PostgreSQL 总是以规范的形式返回一个包括下限和排除上限的范围，即 [)。
DecimalRangeFieldLink to this heading#存储一组浮点数值范围。基于 DecimalField。在数据库中由 numrange 表示，在 Python 中由 django.db.backends.postgresql.psycopg_any.NumericRange 表示。
可选。列表和元组输入的 bounds 值。默认为包含下界，不包含上界，即 [) （有关 不同边界 的详细信息，请参阅 PostgreSQL 文档）。default_bounds 不用于 django.db.backends.postgresql.psycopg_any.NumericRange 输入。
DateTimeRangeFieldLink to this heading#存储一组时间戳范围。基于 DateTimeField。在数据库中由 tstzrange 表示，在 Python 中由 django.db.backends.postgresql.psycopg_any.DateTimeTZRange 表示。
可选。列表和元组输入的 bounds 值。默认为包含下界，不包含上界，即 [) （有关 不同边界 的详细信息，请参阅 PostgreSQL 文档）。default_bounds 不用于 django.db.backends.postgresql.psycopg_any.DateTimeTZRange 输入。
DateRangeFieldLink to this heading#存储一组日期范围。基于 DateField。在数据库中由 daterange 表示，在 Python 中由 django.db.backends.postgresql.psycopg_any.DateRange 表示。
无论在保存数据时指定的边界是什么，PostgreSQL 总是以规范的形式返回一个包括下限和排除上限的范围，即 [)。
对于范围字段，有许多自定义查找和转换。它们适用于所有上述字段，但我们将使用以下示例模型：
\nfrom django.contrib.postgres.fields import IntegerRangeField\nfrom django.db import models\n\n\nclass Event(models.Model):\n name = models.CharField(max_length=200)\n ages = IntegerRangeField()\n start = models.DateTimeField()\n\n def __str__(self):\n return self.name\n我们还将使用以下示例对象：
\n>>> import datetime\n>>> from django.utils import timezone\n>>> now = timezone.now()\n>>> Event.objects.create(name="Soft play", ages=(0, 10), start=now)\n>>> Event.objects.create(\n... name="Pub trip", ages=(21, None), start=now - datetime.timedelta(days=1)\n... )\n和 NumericRange：
>>> from django.db.backends.postgresql.psycopg_any import NumericRange\n与其他 PostgreSQL 字段一样，有三个标准的包含运算符。contains、contained_by 和 overlap，分别使用 SQL 运算符 @>、<@ 和 &&。
containsLink to this heading#>>> Event.objects.filter(ages__contains=NumericRange(4, 5))\n<QuerySet [<Event: Soft play>]>\ncontained_byLink to this heading#>>> Event.objects.filter(ages__contained_by=NumericRange(0, 15))\n<QuerySet [<Event: Soft play>]>\ncontained_by 查询也适用于非范围字段类型： SmallAutoField, AutoField, BigAutoField, SmallIntegerField, IntegerField, BigIntegerField, DecimalField, FloatField, DateField, 和 DateTimeField。例如：
>>> from django.db.backends.postgresql.psycopg_any import DateTimeTZRange\n>>> Event.objects.filter(\n... start__contained_by=DateTimeTZRange(\n... timezone.now() - datetime.timedelta(hours=1),\n... timezone.now() + datetime.timedelta(hours=1),\n... ),\n... )\n<QuerySet [<Event: Soft play>]>\noverlapLink to this heading#>>> Event.objects.filter(ages__overlap=NumericRange(8, 12))\n<QuerySet [<Event: Soft play>]>\n范围字段支持标准查询：lt、gt、lte 和 gte。这些并没有特别大的帮助——它们先比较下界，然后在必要时才比较上界。这也是用于按范围字段排序的策略。最好是使用特定的范围比较运算符。
fully_ltLink to this heading#返回的范围严格小于传入的范围。换句话说，返回范围内的所有点都小于传入范围内的所有点。
\n>>> Event.objects.filter(ages__fully_lt=NumericRange(11, 15))\n<QuerySet [<Event: Soft play>]>\nfully_gtLink to this heading#返回的范围严格大于传入的范围。换句话说，返回范围内的所有点都大于传入范围内的所有点。
\n>>> Event.objects.filter(ages__fully_gt=NumericRange(11, 15))\n<QuerySet [<Event: Pub trip>]>\nnot_ltLink to this heading#返回的范围不包含任何小于传入范围的点，即返回范围的下界至少是传入范围的下界。
\n>>> Event.objects.filter(ages__not_lt=NumericRange(0, 15))\n<QuerySet [<Event: Soft play>, <Event: Pub trip>]>\nnot_gtLink to this heading#返回的范围不包含任何大于传入范围的点，也就是说，返回的范围的上界最多就是传入范围的上界。
\n>>> Event.objects.filter(ages__not_gt=NumericRange(3, 10))\n<QuerySet [<Event: Soft play>]>\nadjacent_toLink to this heading#返回的范围与传入的范围共享一个边界。
\n>>> Event.objects.filter(ages__adjacent_to=NumericRange(10, 21))\n<QuerySet [<Event: Soft play>, <Event: Pub trip>]>\n范围字段支持几个额外的查找。
\nstartswithLink to this heading#返回的对象具有给定的下界。可以链入基础字段的有效查找。
\n>>> Event.objects.filter(ages__startswith=21)\n<QuerySet [<Event: Pub trip>]>\nendswithLink to this heading#返回的对象具有给定的上界。可以链入基础字段的有效查找。
\n>>> Event.objects.filter(ages__endswith=10)\n<QuerySet [<Event: Soft play>]>\nisemptyLink to this heading#返回的对象是空的范围。可以链到有效的查找 BooleanField。
>>> Event.objects.filter(ages__isempty=True)\n<QuerySet []>\nlower_incLink to this heading#根据传递的布尔值，返回具有包含或不包含下界的对象。可以链到有效的查找 BooleanField 的对象。
>>> Event.objects.filter(ages__lower_inc=True)\n<QuerySet [<Event: Soft play>, <Event: Pub trip>]>\nlower_infLink to this heading#根据传递的布尔值，返回具有无界（无限）或仅有下界的对象。可以链到有效的查找 BooleanField。
>>> Event.objects.filter(ages__lower_inf=True)\n<QuerySet []>\nupper_incLink to this heading#根据传递的布尔值，返回具有包含或不包含上界的对象。可以链到有效的查找 BooleanField 的对象。
>>> Event.objects.filter(ages__upper_inc=True)\n<QuerySet []>\nupper_infLink to this heading#根据传递的布尔值，返回具有无界（无限）或仅有上界的对象。可以链到有效的查找 BooleanField。
>>> Event.objects.filter(ages__upper_inf=True)\n<QuerySet [<Event: Pub trip>]>\nPostgreSQL 允许定义自定义范围类型。Django 的模型和表单字段实现使用以下基类，并且 psycopg 提供了一个 register_range() 函数来允许使用自定义范围类型。
模型范围字段的基类。
\n要使用的模型字段类。
\n要使用的范围类型。
\n要使用的表单字段类。应该是 django.contrib.postgres.forms.BaseRangeField 的子类。
表范围字段的基类。
\n要使用的表字段。
\n要使用的范围类型。
\nPostgreSQL 提供了一组 SQL 运算符，这些运算符可以和范围数据类型一起使用（参见 `the PostgreSQL documentation for the full details of range operators `_ ）。这个类的目的是作为一种方便的方法，以避免排版错误。运算符名称与相应的查找名称重叠。
\nclass RangeOperators:\n EQUAL = "="\n NOT_EQUAL = "<>"\n CONTAINS = "@>"\n CONTAINED_BY = "<@"\n OVERLAPS = "&&"\n FULLY_LT = "<<"\n FULLY_GT = ">>"\n NOT_LT = "&>"\n NOT_GT = "&<"\n ADJACENT_TO = "-|-"\n如果 True （默认），则下界为包含 '['，否则为不包含 '('。
如果 False （默认），则上界为包含 ')'，否则为不包含 ']'。
RangeBoundary() 表达式表示范围边界。它可以与自定义的范围函数一起使用，预期边界，例如定义 ExclusionConstraint。参见 `the PostgreSQL documentation for the full details `_ 。