--- title: "Bidang-bidang model khusus PostgreSQL" version: 3.1 locale: id source: https://docs.djangoproject.com/id/3.1/ref/contrib/postgres/fields/ canonical: https://djangodocs.dev/id/3.1/ref/contrib/postgres/fields/ --- # Bidang-bidang model khusus PostgreSQL Semua dari bidang ini tersedia dari modul `django.contrib.postgres.fields`. ## Mengindeks bidang-bidang ini [`Index`](/id/3.1/ref/models/indexes/#django.db.models.Index) and [`Field.db_index`](/id/3.1/ref/models/fields/#django.db.models.Field.db_index) both create a B-tree index, which isn't particularly helpful when querying complex data types. Indexes such as [`GinIndex`](/id/3.1/ref/contrib/postgres/indexes/#django.contrib.postgres.indexes.GinIndex) and [`GistIndex`](/id/3.1/ref/contrib/postgres/indexes/#django.contrib.postgres.indexes.GistIndex) are better suited, though the index choice is dependent on the queries that you're using. Generally, GiST may be a good choice for the [range fields](#range-fields) and [`HStoreField`](#django.contrib.postgres.fields.HStoreField), and GIN may be helpful for [`ArrayField`](#django.contrib.postgres.fields.ArrayField). ## `ArrayField` #### `class ArrayField(base_field, size=None, **options)` A field for storing lists of data. Most field types can be used, and you pass another field instance as the [`base_field`](#django.contrib.postgres.fields.ArrayField.base_field). You may also specify a [`size`](#django.contrib.postgres.fields.ArrayField.size). `ArrayField` can be nested to store multi-dimensional arrays. Jika anda memberikan bidang [`default`](/id/3.1/ref/models/fields/#django.db.models.Field.default), pastikan itu adalah callable seperti `list` (untuk sebuah nilai kosong) atau sebuah callable yang mengembalikan list (seperti sebuah fungsi). Salah menggunakan `default=[]` membuat awalan yang berubah-ubah yaitu dibagi diantara semua contoh dari `ArrayField`. #### `base_field` Ini adalah sebuah argumen diwajibkan. Menentukan jenis data yang mendasari dan perilaku dari larik. Itu harus berupa sebuah contoh dari sub kelas dari [`Field`](/id/3.1/ref/models/fields/#django.db.models.Field). Sebagai contoh, itu dapat berupa sebuah [`IntegerField`](/id/3.1/ref/models/fields/#django.db.models.IntegerField) atau [`CharField`](/id/3.1/ref/models/fields/#django.db.models.CharField). Kebanyakan jenis-jenis bidang diizinkan, dengan pengecualian dari itu menangani hubungan data ([`ForeignKey`](/id/3.1/ref/models/fields/#django.db.models.ForeignKey), [`OneToOneField`](/id/3.1/ref/models/fields/#django.db.models.OneToOneField) dan [`ManyToManyField`](/id/3.1/ref/models/fields/#django.db.models.ManyToManyField)). Itu memungkinkan menyarang bidang-bidang larik - anda dapat menentukan sebuah instance dari `ArrayField` sebagai `base_field`. Sebagai contoh: ``` from django.contrib.postgres.fields import ArrayField from django.db import models class ChessBoard(models.Model): board = ArrayField( ArrayField( models.CharField(max_length=10, blank=True), size=8, ), size=8, ) ``` Perubahan dari nilai-nilai diantara basisdata dan model, pengesahan dari data dan konfigurasi, dan serialisasi adalah semua dilimpahkan ke bidang dasar pokok. #### `size` Ini adalah sebuah argumen pilihan. Jika dilewatkan, larik akan memiliki ukuran maksimal seperti ditentukan. Ini akan dilewatkan ke basisdata meskipun PostgreSQL saat sekarang tidak melaksanakan batasan. > **Note** > > When nesting `ArrayField`, whether you use the `size` parameter or not, > PostgreSQL requires that the arrays are rectangular: > > ``` > from django.contrib.postgres.fields import ArrayField > from django.db import models > > class Board(models.Model): > pieces = ArrayField(ArrayField(models.IntegerField())) > > # Valid > Board(pieces=[ > [2, 3], > [2, 1], > ]) > > # Not valid > Board(pieces=[ > [2, 3], > [2], > ]) > ``` > > Jika bentuk-bentuk tidak beraturan, kemudian bidang pokok harus dibuat null dan nilai-nilai ditambah dengan `None`. ### Meminta `ArrayField` Ada sejumlah pencarian penyesuaian dan merubah untuk [`ArrayField`](#django.contrib.postgres.fields.ArrayField). Kami akan menggunakan model contoh berikut: ``` from django.contrib.postgres.fields import ArrayField from django.db import models class Post(models.Model): name = models.CharField(max_length=200) tags = ArrayField(models.CharField(max_length=200), blank=True) def __str__(self): return self.name ``` #### `contains` Pencarian [`contains`](/id/3.1/ref/models/querysets/#std-fieldlookup-contains) ditimpa pada [`ArrayField`](#django.contrib.postgres.fields.ArrayField). Obyek-obyek dikembalikan akan menjadi mereka dimana nilai-nilai dilewatkan adalah himpuna bagian dari data. Itu menggunakan penghubung SQL `@>`. Sebagai contoh: ``` >>> Post.objects.create(name='First post', tags=['thoughts', 'django']) >>> Post.objects.create(name='Second post', tags=['thoughts']) >>> Post.objects.create(name='Third post', tags=['tutorial', 'django']) >>> Post.objects.filter(tags__contains=['thoughts']) , ]> >>> Post.objects.filter(tags__contains=['django']) , ]> >>> Post.objects.filter(tags__contains=['django', 'thoughts']) ]> ``` #### `contained_by` Ini adalah kebalikan dari pencarian [`contains`](#std-fieldlookup-arrayfield.contains) \- obyek-obyek dikembalikan akan menjadi mereka dimana data adalah himpunan bagian dari nilai-nilai dilewatkan. Itu menggunakan penghubung SQL `@`. Sebagai contoh: ``` >>> Post.objects.create(name='First post', tags=['thoughts', 'django']) >>> Post.objects.create(name='Second post', tags=['thoughts']) >>> Post.objects.create(name='Third post', tags=['tutorial', 'django']) >>> Post.objects.filter(tags__contained_by=['thoughts', 'django']) , ]> >>> Post.objects.filter(tags__contained_by=['thoughts', 'django', 'tutorial']) , , ]> ``` #### `overlap` Mengembalikan obyek-obyek dimana data berbagi hasil apapun dengan nilai-nilai dilewatkan. menggunakan penghubung SQL `&&`. Sebagai contoh: ``` >>> Post.objects.create(name='First post', tags=['thoughts', 'django']) >>> Post.objects.create(name='Second post', tags=['thoughts']) >>> Post.objects.create(name='Third post', tags=['tutorial', 'django']) >>> Post.objects.filter(tags__overlap=['thoughts']) , ]> >>> Post.objects.filter(tags__overlap=['thoughts', 'tutorial']) , , ]> ``` #### `len` Mengembalikan panjang dari larik. Pencarian tersedia setelah itu adalah mereka tersedia untuk [`IntegerField`](/id/3.1/ref/models/fields/#django.db.models.IntegerField). Sebagai contoh: ``` >>> Post.objects.create(name='First post', tags=['thoughts', 'django']) >>> Post.objects.create(name='Second post', tags=['thoughts']) >>> Post.objects.filter(tags__len=1) ]> ``` #### Perubahan indeks Indeks merubah indeks menjadi larik. Integer bukan-negatif apapun dapat digunakan. TIdak ada kesalahan jika itu melebihi [`size`](#django.contrib.postgres.fields.ArrayField.size) dari larik. Pencarian tersedia setelah perubahan adalah itu dari [`base_field`](#django.contrib.postgres.fields.ArrayField.base_field). Sebagai contoh: ``` >>> Post.objects.create(name='First post', tags=['thoughts', 'django']) >>> Post.objects.create(name='Second post', tags=['thoughts']) >>> Post.objects.filter(tags__0='thoughts') , ]> >>> Post.objects.filter(tags__1__iexact='Django') ]> >>> Post.objects.filter(tags__276='javascript') ``` > **Note** > > PostgreSQL menggunakan pengindeksan berdasarkan-1 untuk bidang larik ketika menulis SQL mentah. bagaimanapun indeks-indeks ini dan mereka digunakan dalam [`slices`](#std-fieldlookup-arrayfield.slice) menggunakan pengindeksan berdasarkan-0 untuk tetap dengan Python. #### Perubahan potongan Potongan perubahan mengambil potongan dari larik. Apapun dua bukan-negatif integer dapat digunakan, dipisahkan oleh garis bawa tunggal. Pencarian setelah perubahan tidak berubah. Sebagai contoh: ``` >>> Post.objects.create(name='First post', tags=['thoughts', 'django']) >>> Post.objects.create(name='Second post', tags=['thoughts']) >>> Post.objects.create(name='Third post', tags=['django', 'python', 'thoughts']) >>> Post.objects.filter(tags__0_1=['thoughts']) , ]> >>> Post.objects.filter(tags__0_2__contains=['thoughts']) , ]> ``` > **Note** > > PostgreSQL menggunakan pengindeksan berdasarkan-1 untuk bidang larik ketika menulis SQL mentah. bagaimanapun potongan-potongan ini dan itu yang digunakan dalam [`indexes`](#std-fieldlookup-arrayfield.index) menggunakan pengindeksan berdasarkan-0 untuk tetap dengan Python. > **Larik dimensi banyak dengan indeks dan potongan** > > PostgreSQL mempunyai beberapa perilaku esotorik ketika menggunakan pengindeksan dan pemotongan pada larik banyak dimensi. itu akan selalu bekerja mencapat ke data pokok akhir, tetapi kebanyakan potongan berperilaku aneh pada tingkat basisdata dan tidak dapat didukung dalam logika, gaya tetap oleh Django. ## Bidang `CIText` #### `class CIText(**options)` Sebuah percampuran untuk membuat bidang-bidang teks kasus-tidak-peka didukung oleh [citext](https://www.postgresql.org/docs/current/citext.html) type. Baca mengenai [the performance considerations](https://www.postgresql.org/docs/current/citext.html#id-1.11.7.17.7) sebelum menggunakan itu. Untuk menggunakan `citext`, gunakan tindakan [`CITextExtension`](/id/3.1/ref/contrib/postgres/operations/#django.contrib.postgres.operations.CITextExtension) pada [setup the citext extension](/id/3.1/ref/contrib/postgres/operations/#create-postgresql-extensions) di PostgreSQL sebelum tindakan perpindahan pertama `CreateModel`. Jika anda sedang menggunakan sebuah [`ArrayField`](#django.contrib.postgres.fields.ArrayField) dari bidang `CIText`, anda harus menambah `'django.contrib.postgres'` dalam [`INSTALLED_APPS`](/id/3.1/ref/settings/#std-setting-INSTALLED_APPS) anda, sebaliknya nilai bidang akan muncul sebagai string seperti `'{thoughts,django}'`. Beberapa bidang yang menggunakan mixin disediakan: #### `class CICharField(**options)` #### `class CIEmailField(**options)` #### `class CITextField(**options)` Bidang ini subkelas [`CharField`](/id/3.1/ref/models/fields/#django.db.models.CharField), [`EmailField`](/id/3.1/ref/models/fields/#django.db.models.EmailField), dan [`TextField`](/id/3.1/ref/models/fields/#django.db.models.TextField), masing-masing. `max_length` tidak akan dipaksa dalam basisdata sejak perilaku `citext` mirip pada teks `text` PostgreSQL. ## `HStoreField` #### `class HStoreField(**options)` Sebuah bidang untuk menyimpan pasangan nilai-kunci. Jenis data Python adalah sebuah `dict`. Kunci-kunci harus berupa string, dan nilai-nilai mungkin salah satu string atau null (`None` dalam Python). Untuk menggunakan bidang ini, anda akan butuh untuk: 1. Tambah `'django.contrib.postgres'` dalam [`INSTALLED_APPS`](/id/3.1/ref/settings/#std-setting-INSTALLED_APPS) anda. 2. [Setup the hstore extension](/id/3.1/ref/contrib/postgres/operations/#create-postgresql-extensions) di PostgreSQL. Anda akan melihat sebuah kesalahan seperti `can't adapt type 'dict'` jika anda melewati langkah pertama, atau `type "hstore" does not exist` jika anda melewati kedua. > **Note** > > Pada kesempatan itu mungkin berguna untuk membutuhkan atau membatasi kunci-kunci yang sah untuk bidang diberikan. Ini dapat dilakukan menggunakan [`KeysValidator`](/id/3.1/ref/contrib/postgres/validators/#django.contrib.postgres.validators.KeysValidator). ### Meminta `HStoreField` Sebagai tambahan pada kemampuan untuk pencarian berdasarkan kunci, ada angka dari pencarian penyesuaian tersedia untuk `HStoreField`. Kami akan menggunakan model contoh berikut: ``` from django.contrib.postgres.fields import HStoreField from django.db import models class Dog(models.Model): name = models.CharField(max_length=200) data = HStoreField() def __str__(self): return self.name ``` #### Kunci pencarian To query based on a given key, you can use that key as the lookup name: ``` >>> Dog.objects.create(name='Rufus', data={'breed': 'labrador'}) >>> Dog.objects.create(name='Meg', data={'breed': 'collie'}) >>> Dog.objects.filter(data__breed='collie') ]> ``` Anda dapat mengikat pencarian lain setelah pencarian kunci: ``` >>> Dog.objects.filter(data__breed__contains='l') , ]> ``` Jika kunci yang anda ahrapkan untuk meminta berdasarkan ketidakcocokan dengan nama dari pencarian lain, anda butuh menggunakan pencarian [`hstorefield.contains`](#std-fieldlookup-hstorefield.contains) lookup sebagai gantinya. > **Warning** > > Sejak string apapun dapat berupa sebuah kunci dalam nilai hstore, pencarian apapun dari pada tersebut didaftar dibawah akan diartikan sebagai sebuah pencarian kunci. Tidak ada kesalahan akan dimunculkan. Ekstra hati-hati untuk menulis kesalahan, dan selalu memeriksa permintaan anda bekerja sesuai maksud anda. #### `contains` Pencarian [`contains`](/id/3.1/ref/models/querysets/#std-fieldlookup-contains) ditimpa pada [`HStoreField`](#django.contrib.postgres.fields.HStoreField). Obyek-obyek yang dikembalikan adalah itu dimana `dict` dari pasangan nilai-kunci yang diberikan dikandung semua dalam bidang. Itu menggunakan penghubung SQ: `A>`. Sebagai contoh: ``` >>> Dog.objects.create(name='Rufus', data={'breed': 'labrador', 'owner': 'Bob'}) >>> Dog.objects.create(name='Meg', data={'breed': 'collie', 'owner': 'Bob'}) >>> Dog.objects.create(name='Fred', data={}) >>> Dog.objects.filter(data__contains={'owner': 'Bob'}) , ]> >>> Dog.objects.filter(data__contains={'breed': 'collie'}) ]> ``` #### `contained_by` Ini adalah kebalikan dari pencarian [`contains`](#std-fieldlookup-hstorefield.contains) \- obyek-obyek dikembalikan akan berupa itu dimana pasangan nilai-kunci pada obyek adalah sebuah jimpunan bagian dari itu dalam nilai dilewatkan. Itu menggunakan penghubung SQL `<@`. Sebagai contoh: ``` >>> Dog.objects.create(name='Rufus', data={'breed': 'labrador', 'owner': 'Bob'}) >>> Dog.objects.create(name='Meg', data={'breed': 'collie', 'owner': 'Bob'}) >>> Dog.objects.create(name='Fred', data={}) >>> Dog.objects.filter(data__contained_by={'breed': 'collie', 'owner': 'Bob'}) , ]> >>> Dog.objects.filter(data__contained_by={'breed': 'collie'}) ]> ``` #### `has_key` Mengembalikan obyek-obyek dimana kunci diberikan adalah dalam data. Menggunakan penghubung SQL `?`. Sebagai contoh: ``` >>> Dog.objects.create(name='Rufus', data={'breed': 'labrador'}) >>> Dog.objects.create(name='Meg', data={'breed': 'collie', 'owner': 'Bob'}) >>> Dog.objects.filter(data__has_key='owner') ]> ``` #### `has_any_keys` Mengembalikan obyek-obyek dimana apapun dari kunci diberikan adalah dalam data. Menggunakan penghubung SQL `?|`. Sebagai contoh: ``` >>> Dog.objects.create(name='Rufus', data={'breed': 'labrador'}) >>> Dog.objects.create(name='Meg', data={'owner': 'Bob'}) >>> Dog.objects.create(name='Fred', data={}) >>> Dog.objects.filter(data__has_any_keys=['owner', 'breed']) , ]> ``` #### `has_keys` Mengembalikan obyek-obyek dimana semua kunci diberikan dalam data. Menggunakan penghubung SQL `?&`. Sebagai contoh: ``` >>> Dog.objects.create(name='Rufus', data={}) >>> Dog.objects.create(name='Meg', data={'breed': 'collie', 'owner': 'Bob'}) >>> Dog.objects.filter(data__has_keys=['breed', 'owner']) ]> ``` #### `keys` Mengembalikan obyek-obyek dimana larik dari kunci adalah nilai diberikan. Catat bahwa urutan tidak dijamin untuk menjadi handal, jadi perubahan ini utamanya berguna untuk menggunakan penghubung dengan pencarian pada [`ArrayField`](#django.contrib.postgres.fields.ArrayField). Menggunakan fungsi SQL `akeys()`. Sebagai contoh: ``` >>> Dog.objects.create(name='Rufus', data={'toy': 'bone'}) >>> Dog.objects.create(name='Meg', data={'breed': 'collie', 'owner': 'Bob'}) >>> Dog.objects.filter(data__keys__overlap=['breed', 'toy']) , ]> ``` #### `values` Returns objects where the array of values is the given value. Note that the order is not guaranteed to be reliable, so this transform is mainly useful for using in conjunction with lookups on [`ArrayField`](#django.contrib.postgres.fields.ArrayField). Uses the SQL function `avals()`. For example: ``` >>> Dog.objects.create(name='Rufus', data={'breed': 'labrador'}) >>> Dog.objects.create(name='Meg', data={'breed': 'collie', 'owner': 'Bob'}) >>> Dog.objects.filter(data__values__contains=['collie']) ]> ``` ## `JSONField` #### `class JSONField(encoder=None, **options)` Sebuah bidang untuk menyimpan data tersandi JSON. Dalam Python data diwakili dalam bentuk asli Python nya: dictionary, string, angka, booelan dan `None`. #### `encoder` Sebuah pilihan kelas penyandian-JSON untuk menserialisasikan jenis-jenis data tidak didukung oleh penserial JSON (`datetime`, `uuid`, dll.). Sebagai contoh, anda dapat menggunakan kelas [`DjangoJSONEncoder`](/id/3.1/topics/serialization/#django.core.serializers.json.DjangoJSONEncoder) atau sub kelas [`json.JSONEncoder`](https://docs.python.org/3/library/json.html#json.JSONEncoder) apapun. Ketika nilai diambil dari basisdata, itu akan berupa dalam bentuk dipilih oleh penyandi penyesuaian (kebanyakan sering sebuah string), jadi anda akan butuh mengambil langkah-langkah tambahan untuk merubah nilai kembali ke jenis data awalan ([`Model.from_db()`](/id/3.1/ref/models/instances/#django.db.models.Model.from_db) dan [`Field.from_db_value()`](/id/3.1/ref/models/fields/#django.db.models.Field.from_db_value) adalah dua kaitan memungkinkan untuk tujuan tersebut). Deserialisasi anda mungkin butuh dijelaskan untuk fakta bahwa anda tidak bisa memastikan dari jenis masukan. Sebagai contoh, anda menjalankan resiko dari mengembalikan sebuah `datetime` yang sebenarnya baru terjadi menjadi bentuk sama dipilih untuk `datetime`. Jika anda memberikan bidang [`default`](/id/3.1/ref/models/fields/#django.db.models.Field.default), pastikan itu adalah callable seperti `dict` (untuk sebuah awalan kosong) atau sebuah callable yang mengembalikan sebuah dict (seperti sebuah fungsi). Tidak tepat menggunakan `default={}` membuat sebuah awalan yang tidak tetap yaitu dibagi diantara semua contoh-contoh dari `JSONField`. > **Note** > > PostgreSQL mempunyai dua jenis data berdasarkan JSON asli: `json` dan `jsonb`. Perbedaan utama diantara mereka adalah bagaimana mereka disimpan dan bagaimana mereka dapat diminta. Bidang `json` PostgreSQL disimpan sebagai perwakilan string asli dari JSON dan harus disandikan dengan cepat ketika permintaan berdasarkan pada kunci-kunci. Bidang `jsonb` disimpan berdasarkan pada struktur sebenarnya dari JSON yang mengizinkan pengindeksan. Pertukaran adalah tambahan biaya kecil pada menulis ke bidang `jsonb` field. `JSONField` menggunakan `jsonb`. > **Deprecated since Django 3.1** > > Ditinggalkan sejak versi 3.1: Use [`django.db.models.JSONField`](/id/3.1/ref/models/fields/#django.db.models.JSONField) instead. ### Meminta `JSONField` See [Meminta JSONField](/id/3.1/topics/db/queries/#querying-jsonfield) for details. ## Bidang Jangkauan Ada lima jenis jangkauan bidang, berhubungan ke jenis jangkauan siap-pakai dalam PostgreSQL. Bidang-bidang ini digunakan untuk menyimpan jangkauan dari nilai; sebagai contoh stempel waktu awal dan akhir dari sebuah acara, atau jangkauan dari umur sebuah aktivitas yang cocok. All of the range fields translate to [psycopg2 Range objects](https://www.psycopg.org/docs/extras.html#adapt-range) in Python, but also accept tuples as input if no bounds information is necessary. The default is lower bound included, upper bound excluded, that is `[)` (see the PostgreSQL documentation for details about [different bounds](https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO)). ### `IntegerRangeField` #### `class IntegerRangeField(**options)` Menyimpan jangkauan integer. Berdasarkan pada [`IntegerField`](/id/3.1/ref/models/fields/#django.db.models.IntegerField). Diwakilkan oleh `int4range` dalam basisdata dan [`NumericRange`](https://www.psycopg.org/docs/extras.html#psycopg2.extras.NumericRange) dalam Python. Regardless of the bounds specified when saving the data, PostgreSQL always returns a range in a canonical form that includes the lower bound and excludes the upper bound, that is `[)`. ### `BigIntegerRangeField` #### `class BigIntegerRangeField(**options)` Menyimpan jangkauan integer besar. Berdasarkan pada [`BigIntegerField`](/id/3.1/ref/models/fields/#django.db.models.BigIntegerField). Diwakilkan oleh `int8range` dalam basisdata dan [`NumericRange`](https://www.psycopg.org/docs/extras.html#psycopg2.extras.NumericRange) dalam Python. Regardless of the bounds specified when saving the data, PostgreSQL always returns a range in a canonical form that includes the lower bound and excludes the upper bound, that is `[)`. ### `DecimalRangeField` #### `class DecimalRangeField(**options)` Menyimpan jangkauan dari nilai floating point. Berdasarkan pada sebuah [`DecimalField`](/id/3.1/ref/models/fields/#django.db.models.DecimalField). Diwakili oleh sebuah `numrange` dalam basisdata dan sebuah [`NumericRange`](https://www.psycopg.org/docs/extras.html#psycopg2.extras.NumericRange) di Python. ### `DateTimeRangeField` #### `class DateTimeRangeField(**options)` Menyimpan jangkauan timestamp. Berdasarkan pada [`DateTimeField`](/id/3.1/ref/models/fields/#django.db.models.DateTimeField). Diwakilkan oleh `tstzrange` dalam basisdata dan [`DateTimeTZRange`](https://www.psycopg.org/docs/extras.html#psycopg2.extras.DateTimeTZRange) dan Python. ### `DateRangeField` #### `class DateRangeField(**options)` Menyimpan jangkauan date. Berdasarkan pada [`DateField`](/id/3.1/ref/models/fields/#django.db.models.DateField). Diwakilkan oleh `daterange` dalam basisdata dan [`DateRange`](https://www.psycopg.org/docs/extras.html#psycopg2.extras.DateRange) dalam Python. Regardless of the bounds specified when saving the data, PostgreSQL always returns a range in a canonical form that includes the lower bound and excludes the upper bound, that is `[)`. ### Meminta Jangkauan Bidang Ada sejumlah pencarian penyesuaian dan perubahan untuk bidang jangkauan. Mereka tersedia pada semua bidang-bidang diatas, tetapi kami akan menggunakan model contoh berikut: ``` from django.contrib.postgres.fields import IntegerRangeField from django.db import models class Event(models.Model): name = models.CharField(max_length=200) ages = IntegerRangeField() start = models.DateTimeField() def __str__(self): return self.name ``` Kami akan juga menggunakan obyek contoh berikut: ``` >>> import datetime >>> from django.utils import timezone >>> now = timezone.now() >>> Event.objects.create(name='Soft play', ages=(0, 10), start=now) >>> Event.objects.create(name='Pub trip', ages=(21, None), start=now - datetime.timedelta(days=1)) ``` dan `NumericRange`: ``` >>> from psycopg2.extras import NumericRange ``` #### Fungsi-fungsi penahanan Seperti bidang-bidang PostgreSQL lainnya, ada tiga standar penahanan penghubung: `contains`, `contained_by` dan `overlap`, menggunakan penghubung SQL `@>`, `<@`, dan `&&` masing-masing. ##### `contains` ``` >>> Event.objects.filter(ages__contains=NumericRange(4, 5)) ]> ``` ##### `contained_by` ``` >>> Event.objects.filter(ages__contained_by=NumericRange(0, 15)) ]> ``` The `contained_by` lookup is also available on the non-range field types: [`SmallAutoField`](/id/3.1/ref/models/fields/#django.db.models.SmallAutoField), [`AutoField`](/id/3.1/ref/models/fields/#django.db.models.AutoField), [`BigAutoField`](/id/3.1/ref/models/fields/#django.db.models.BigAutoField), [`SmallIntegerField`](/id/3.1/ref/models/fields/#django.db.models.SmallIntegerField), [`IntegerField`](/id/3.1/ref/models/fields/#django.db.models.IntegerField), [`BigIntegerField`](/id/3.1/ref/models/fields/#django.db.models.BigIntegerField), [`DecimalField`](/id/3.1/ref/models/fields/#django.db.models.DecimalField), [`FloatField`](/id/3.1/ref/models/fields/#django.db.models.FloatField), [`DateField`](/id/3.1/ref/models/fields/#django.db.models.DateField), and [`DateTimeField`](/id/3.1/ref/models/fields/#django.db.models.DateTimeField). For example: ``` >>> from psycopg2.extras import DateTimeTZRange >>> Event.objects.filter( ... start__contained_by=DateTimeTZRange( ... timezone.now() - datetime.timedelta(hours=1), ... timezone.now() + datetime.timedelta(hours=1), ... ), ... ) ]> ``` > **Changed in Django 3.1** > > Support for [`SmallAutoField`](/id/3.1/ref/models/fields/#django.db.models.SmallAutoField), > [`AutoField`](/id/3.1/ref/models/fields/#django.db.models.AutoField), > [`BigAutoField`](/id/3.1/ref/models/fields/#django.db.models.BigAutoField), > [`SmallIntegerField`](/id/3.1/ref/models/fields/#django.db.models.SmallIntegerField), and > [`DecimalField`](/id/3.1/ref/models/fields/#django.db.models.DecimalField) was added. ##### `overlap` ``` >>> Event.objects.filter(ages__overlap=NumericRange(8, 12)) ]> ``` #### Fungsi perbandingan Bidang jangkauan mendukung pencarian standar: [`lt`](/id/3.1/ref/models/querysets/#std-fieldlookup-lt), [`gt`](/id/3.1/ref/models/querysets/#std-fieldlookup-gt), [`lte`](/id/3.1/ref/models/querysets/#std-fieldlookup-lte) dan [`gte`](/id/3.1/ref/models/querysets/#std-fieldlookup-gte). Ini tidak terlalu membantu - mereka membandingkan batasan terendah dahulu dan batasan tertinggi hanya jika dibutuhkan. Ini juga strategi digunakan untuk mengurutkan berdasarkan bidang jangkauan. Itu lebih baik menggunakan penghubung perbandingan jangkauan khusus. ##### `fully_lt` Jangkauan dikembalikan adalah sangat kurang dari jangkauan dilewatkan. Dengan kata lain, semua titik dalam jangkauan dikembalikan kurang dari semua dalam jangkauan dilewatkan. ``` >>> Event.objects.filter(ages__fully_lt=NumericRange(11, 15)) ]> ``` ##### `fully_gt` Jangkauan dikembalikan adalah lebih besar dari jangkauan dilewatkan. Dengan kata lain, semua titik dalam jangkauan dikembalikan lebih besar dari semua dalam jangkauan dilewatkan. ``` >>> Event.objects.filter(ages__fully_gt=NumericRange(11, 15)) ]> ``` ##### `not_lt` Jangkauan dikembalikan tidak mengandung titik apapun kurang dari jangkauan dilewatkan, yaitu batasan terendah dari jangkauan dikembalikan adalah setidaknya batasan terendah dari jangkauan dilewatkan. ``` >>> Event.objects.filter(ages__not_lt=NumericRange(0, 15)) , ]> ``` ##### `not_gt` Jangkauan dikembalikan tidak mengandung titik apapun lebih besar dari jangkauan dilewatkan, yaitu batasan tertinggi dari jangkauan dikembalikan adalah batasan paling tertinggi dari jangkauan dilewatkan. ``` >>> Event.objects.filter(ages__not_gt=NumericRange(3, 10)) ]> ``` ##### `adjacent_to` Jangkauan dikembalikan berbagi sebuah batasan dengan jangkauan dilewatkan. ``` >>> Event.objects.filter(ages__adjacent_to=NumericRange(10, 21)) , ]> ``` #### Meminta menggunakan batasan Ada tiga perubahan tersedia untuk digunakan dalam permintaan. Anda dapat mengeluarkan batasan terendah dan tertinggi, atau meminta berdasarkan kekosongan. ##### `startswith` Obyek-obyek dikembalikan memiliki batasan terendah diberikan. Dapat diikat untuk pencarian sah untuk bidang dasar. ``` >>> Event.objects.filter(ages__startswith=21) ]> ``` ##### `endswith` Obyek-obyek dikembalikan memiliki batasan tertinggi diberikan. Dapat diikat untuk pencarian sah untuk bidang dasar. ``` >>> Event.objects.filter(ages__endswith=10) ]> ``` ##### `isempty` Obyek-obyek dikembalikan adalah jangkauan kosong. Dapat diikat untuk pencarian sah untuk [`BooleanField`](/id/3.1/ref/models/fields/#django.db.models.BooleanField). ``` >>> Event.objects.filter(ages__isempty=True) ``` ##### `lower_inc` > **New in Django 3.1** Returns objects that have inclusive or exclusive lower bounds, depending on the boolean value passed. Can be chained to valid lookups for a [`BooleanField`](/id/3.1/ref/models/fields/#django.db.models.BooleanField). ``` >>> Event.objects.filter(ages__lower_inc=True) , ]> ``` ##### `lower_inf` > **New in Django 3.1** Returns objects that have unbounded (infinite) or bounded lower bound, depending on the boolean value passed. Can be chained to valid lookups for a [`BooleanField`](/id/3.1/ref/models/fields/#django.db.models.BooleanField). ``` >>> Event.objects.filter(ages__lower_inf=True) ``` ##### `upper_inc` > **New in Django 3.1** Returns objects that have inclusive or exclusive upper bounds, depending on the boolean value passed. Can be chained to valid lookups for a [`BooleanField`](/id/3.1/ref/models/fields/#django.db.models.BooleanField). ``` >>> Event.objects.filter(ages__upper_inc=True) ``` ##### `upper_inf` > **New in Django 3.1** Returns objects that have unbounded (infinite) or bounded upper bound, depending on the boolean value passed. Can be chained to valid lookups for a [`BooleanField`](/id/3.1/ref/models/fields/#django.db.models.BooleanField). ``` >>> Event.objects.filter(ages__upper_inf=True) ]> ``` ### Menentukan jenis jangkauan anda sendiri PostgreSQL mengizinkan pengertian dari jenis-jenis jangkauan penyesuaian. Penerapan model Django dan bidang formulir menggunakan kelas-kelas dasar dibawah, dan psycopg2 menyediakan [`register_range()`](https://www.psycopg.org/docs/extras.html#psycopg2.extras.register_range) untuk mengizinkan penggunaan dari jenis-jenis jangkauan penyesuaian. #### `class RangeField(**options)` Kelas dasar untuk bidang jangkauan model. #### `base_field` Kelas bidang model digunakan. #### `range_type` Jenis jangkauan psycopg2 digunakan. #### `form_field` Kelas bidang formulir digunakan. Harus berupa subkelas dari [`django.contrib.postgres.forms.BaseRangeField`](#django.contrib.postgres.fields.django.contrib.postgres.forms.BaseRangeField). #### `class django.contrib.postgres.forms.BaseRangeField` Kelas dasar untuk formulir bidang jangkauan. #### `base_field` Bidang formulir digunakan. #### `range_type` Jenis jangkauan psycopg2 digunakan. ### Range operators > **New in Django 3.0** #### `class RangeOperators` PostgreSQL provides a set of SQL operators that can be used together with the range data types (see [the PostgreSQL documentation for the full details of range operators](https://www.postgresql.org/docs/current/functions-range.html#RANGE-OPERATORS-TABLE)). This class is meant as a convenient method to avoid typos. The operator names overlap with the names of corresponding lookups. ```python class RangeOperators: EQUAL = '=' NOT_EQUAL = '<>' CONTAINS = '@>' CONTAINED_BY = '<@' OVERLAPS = '&&' FULLY_LT = '<<' FULLY_GT = '>>' NOT_LT = '&>' NOT_GT = '&<' ADJACENT_TO = '-|-' ``` ### Pernyataan RangeBoundary() > **New in Django 3.0** #### `class RangeBoundary(inclusive_lower=True, inclusive_upper=False)` #### `inclusive_lower` If `True` (default), the lower bound is inclusive `'['`, otherwise it's exclusive `'('`. #### `inclusive_upper` If `False` (default), the upper bound is exclusive `')'`, otherwise it's inclusive `']'`. A `RangeBoundary()` expression represents the range boundaries. It can be used with a custom range functions that expected boundaries, for example to define [`ExclusionConstraint`](/id/3.1/ref/contrib/postgres/constraints/#django.contrib.postgres.constraints.ExclusionConstraint). See [the PostgreSQL documentation for the full details](https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-INCLUSIVITY).