PostgreSQL विशिष्ट मॉडल फ़ील्ड

ये सभी फ़ील्ड django.contrib.postgres.fields मॉड्यूल से उपलब्ध हैं।

इन क्षेत्रों को अनुक्रमित करना

Index और Field.db_index दोनों एक बी-ट्री इंडेक्स बनाते हैं, जो जटिल डेटा प्रकारों को क्वेरी करते समय विशेष रूप से उपयोगी नहीं है। GinIndex और GistIndex जैसे इंडेक्स बेहतर अनुकूल हैं, हालांकि इंडेक्स GistIndex आपके द्वारा उपयोग किए जा रहे प्रश्नों पर निर्भर है। आम तौर पर, जीएसटी सीमा क्षेत्र और HStoreField लिए एक अच्छा विकल्प हो सकता है, और GIN ArrayField और JSONField लिए सहायक हो सकता है।

ArrayField

class ArrayField(base_field, size=None, **options) [source]

डेटा की सूची संग्रहीत करने के लिए एक फ़ील्ड। अधिकांश फ़ील्ड प्रकारों का उपयोग किया जा सकता है, आप बस किसी अन्य फ़ील्ड उदाहरण को base_field रूप में base_field । आप एक size भी निर्दिष्ट कर सकते हैं। ArrayField को बहुआयामी सरणियों को संग्रहीत करने के लिए नेस्टेड किया जा सकता है।

यदि आप फ़ील्ड को एक default , तो सुनिश्चित करें कि यह एक कॉल करने योग्य है जैसे कि list (खाली डिफ़ॉल्ट के लिए) या एक कॉल करने योग्य जो सूची (जैसे कि फ़ंक्शन) लौटाता है। default=[] गलत तरीके से उपयोग करना default=[] एक उत्परिवर्तनीय डिफ़ॉल्ट बनाता है जिसे ArrayField सभी उदाहरणों के बीच साझा किया जाता है।

base_field

यह एक आवश्यक तर्क है।

सरणी के लिए अंतर्निहित डेटा प्रकार और व्यवहार को निर्दिष्ट करता है। यह Field के एक उपवर्ग का एक उदाहरण होना चाहिए। उदाहरण के लिए, यह एक IntegerField या एक CharField हो सकता है। अधिकांश फ़ील्ड प्रकारों की अनुमति दी जाती है, जो रिलेशनल डेटा ( OneToOneField , OneToOneField और OneToOneField ) से निपटने के अपवाद हैं।

सरणी फ़ील्ड्स को घोंसला बनाना संभव है - आप ArrayField रूप में base_field का एक उदाहरण निर्दिष्ट कर सकते हैं। उदाहरण के लिए:

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,
    )

डेटाबेस और मॉडल के बीच मूल्यों का परिवर्तन, डेटा और कॉन्फ़िगरेशन का सत्यापन, और क्रमांकन सभी अंतर्निहित आधार क्षेत्र में निर्दिष्ट हैं।

size

यह एक वैकल्पिक तर्क है।

यदि पास किया जाता है, तो सरणी में निर्दिष्ट अधिकतम आकार होगा। इसे डेटाबेस में पास कर दिया जाएगा, हालाँकि वर्तमान में PostgreSQL प्रतिबंध को लागू नहीं करता है।

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],
])

ArrayField

ArrayField लिए कई कस्टम लुकअप और ArrayField । हम निम्नलिखित उदाहरण मॉडल का उपयोग करेंगे:

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

ArrayField पर लुकअप ओवरराइड है। लौटी हुई वस्तुएँ वे होंगी जहाँ पारित किए गए मान डेटा का सबसेट होते हैं। यह SQL ऑपरेटर @> का उपयोग करता है। उदाहरण के लिए:

>>> 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'])
<QuerySet [<Post: First post>, <Post: Second post>]>

>>> Post.objects.filter(tags__contains=['django'])
<QuerySet [<Post: First post>, <Post: Third post>]>

>>> Post.objects.filter(tags__contains=['django', 'thoughts'])
<QuerySet [<Post: First post>]>

contained_by

contains लुकअप का उलटा है - लौटाए गए ऑब्जेक्ट वे होंगे जहां डेटा पास किए गए मानों का सबसेट है। यह SQL ऑपरेटर <@ का उपयोग करता है। उदाहरण के लिए:

>>> 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'])
<QuerySet [<Post: First post>, <Post: Second post>]>

>>> Post.objects.filter(tags__contained_by=['thoughts', 'django', 'tutorial'])
<QuerySet [<Post: First post>, <Post: Second post>, <Post: Third post>]>

overlap

उन वस्तुओं को लौटाता है जहां डेटा पारित किए गए मूल्यों के साथ कोई परिणाम साझा करता है। SQL ऑपरेटर && उपयोग करता है। उदाहरण के लिए:

>>> 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'])
<QuerySet [<Post: First post>, <Post: Second post>]>

>>> Post.objects.filter(tags__overlap=['thoughts', 'tutorial'])
<QuerySet [<Post: First post>, <Post: Second post>, <Post: Third post>]>

len

सरणी की लंबाई देता है। इसके बाद जो लुकअप उपलब्ध हैं, वे IntegerField लिए उपलब्ध हैं। उदाहरण के लिए:

>>> Post.objects.create(name='First post', tags=['thoughts', 'django'])
>>> Post.objects.create(name='Second post', tags=['thoughts'])

>>> Post.objects.filter(tags__len=1)
<QuerySet [<Post: Second post>]>

सूचकांक बदल जाता है

इंडेक्स इंडेक्स को एरे में बदल देता है। किसी भी गैर-नकारात्मक पूर्णांक का उपयोग किया जा सकता है। यदि यह सरणी के size से अधिक है तो कोई त्रुटि नहीं है। ट्रांसफॉर्मेशन के बाद जो लुकअप उपलब्ध हैं, वे base_field । उदाहरण के लिए:

>>> Post.objects.create(name='First post', tags=['thoughts', 'django'])
>>> Post.objects.create(name='Second post', tags=['thoughts'])

>>> Post.objects.filter(tags__0='thoughts')
<QuerySet [<Post: First post>, <Post: Second post>]>

>>> Post.objects.filter(tags__1__iexact='Django')
<QuerySet [<Post: First post>]>

>>> Post.objects.filter(tags__276='javascript')
<QuerySet []>

स्लाइस बदल देती है

स्लाइस ट्रांसफॉर्म अरेंज का स्लाइस लेते हैं। किसी भी दो गैर-नकारात्मक पूर्णांक का उपयोग किया जा सकता है, एक एकल अंडरस्कोर द्वारा अलग किया जाता है। परिवर्तन के बाद उपलब्ध लुकअप नहीं बदलते हैं। उदाहरण के लिए:

>>> 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'])
<QuerySet [<Post: First post>, <Post: Second post>]>

>>> Post.objects.filter(tags__0_2__contains=['thoughts'])
<QuerySet [<Post: First post>, <Post: Second post>]>

CIText फ़ील्ड

class CIText(**options) [source]

citext प्रकार द्वारा समर्थित केस-असंवेदनशील पाठ फ़ील्ड बनाने के लिए एक citext । उपयोग करने से पहले प्रदर्शन के विचारों के बारे में पढ़ें।

citext उपयोग करने के लिए, पहले CreateModel माइग्रेशन ऑपरेशन से पहले PostgreSQL में citext एक्सटेंशन को सेटअप करने के लिए CITextExtension ऑपरेशन का उपयोग करें।

मिश्रण का उपयोग करने वाले कई क्षेत्रों को प्रदान किया गया है:

class CICharField(**options) [source]

class CIEmailField(**options) [source]

class CITextField(**options) [source]

ये क्षेत्र क्रमशः CharField , EmailField और EmailField उपवर्ग CharField हैं।

citext के text प्रकार के समान व्यवहार करने के बाद से citext डेटाबेस में लागू नहीं होगी।

HStoreField

class HStoreField(**options) [source]

कुंजी-मूल्य जोड़े को संग्रहीत करने के लिए एक फ़ील्ड। पायथन डेटा प्रकार का उपयोग एक dict । कुंजी तार होना चाहिए, और मान या तो तार या नल हो सकते हैं (पायथन में None )।

इस फ़ील्ड का उपयोग करने के लिए, आपको निम्न करना होगा:

1. अपने INSTALLED_APPS में 'django.contrib.postgres' जोड़ें।
2. PostgreSQL में hstore एक्सटेंशन को सेटअप करें ।

यदि आप पहले चरण को छोड़ देते हैं तो आपको एक त्रुटि दिखाई देगी, जैसे कि आप can't adapt type 'dict' , या यदि आप दूसरे को छोड़ते type "hstore" does not exist तो type "hstore" does not exist ।

HStoreField

कुंजी द्वारा क्वेरी करने की क्षमता के अलावा, HStoreField लिए कई कस्टम लुकअप उपलब्ध हैं।

हम निम्नलिखित उदाहरण मॉडल का उपयोग करेंगे:

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

मुख्य लुकअप

किसी दिए गए कुंजी के आधार पर क्वेरी करने के लिए, आप उस कुंजी को लुकअप नाम के रूप में उपयोग करते हैं:

>>> Dog.objects.create(name='Rufus', data={'breed': 'labrador'})
>>> Dog.objects.create(name='Meg', data={'breed': 'collie'})

>>> Dog.objects.filter(data__breed='collie')
<QuerySet [<Dog: Meg>]>

आप मुख्य लुकअप के बाद अन्य लुकअप को चेन कर सकते हैं:

>>> Dog.objects.filter(data__breed__contains='l')
<QuerySet [<Dog: Rufus>, <Dog: Meg>]>

यदि कोई कुंजी जिसे आप किसी अन्य लुकअप के नाम के साथ झड़प द्वारा क्वेरी करना चाहते हैं, तो आपको इसके बजाय hstorefield.contains लुकअप का उपयोग करने की आवश्यकता है।

contains

contains लुकअप HStoreField पर ओवरराइड है। लौटे ऑब्जेक्ट वे हैं जहाँ कुंजी-मूल्य वाले जोड़े के दिए गए सभी क्षेत्र में निहित हैं। यह SQL ऑपरेटर @> का उपयोग करता है। उदाहरण के लिए:

>>> 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'})
<QuerySet [<Dog: Rufus>, <Dog: Meg>]>

>>> Dog.objects.filter(data__contains={'breed': 'collie'})
<QuerySet [<Dog: Meg>]>

contained_by

यह लुकअप का उलटा है - वापस लौटाए गए ऑब्जेक्ट वे होंगे, जहां ऑब्जेक्ट पर की-वैल्यू जोड़े पास वैल्यू में शामिल हैं। यह SQL ऑपरेटर <@ का उपयोग करता है। उदाहरण के लिए:

>>> 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'})
<QuerySet [<Dog: Meg>, <Dog: Fred>]>

>>> Dog.objects.filter(data__contained_by={'breed': 'collie'})
<QuerySet [<Dog: Fred>]>

has_key

वह ऑब्जेक्ट लौटाता है जहाँ दी गई कुंजी डेटा में है। SQL ऑपरेटर का उपयोग करता है ? । उदाहरण के लिए:

>>> 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')
<QuerySet [<Dog: Meg>]>

has_any_keys

उन ऑब्जेक्ट्स को लौटाता है जहाँ दिए गए किसी भी कुंजी डेटा में हैं। SQL ऑपरेटर का उपयोग करता है ?| । उदाहरण के लिए:

>>> 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'])
<QuerySet [<Dog: Rufus>, <Dog: Meg>]>

has_keys

उन ऑब्जेक्ट्स को लौटाता है जहाँ दिए गए सभी कुंजी डेटा में हैं। SQL ऑपरेटर का उपयोग करता है ?& उदाहरण के लिए:

>>> Dog.objects.create(name='Rufus', data={})
>>> Dog.objects.create(name='Meg', data={'breed': 'collie', 'owner': 'Bob'})

>>> Dog.objects.filter(data__has_keys=['breed', 'owner'])
<QuerySet [<Dog: Meg>]>

keys

उन वस्तुओं को लौटाता है जहाँ कुंजियों का सरणी दिया गया मान है। ध्यान दें कि आदेश विश्वसनीय होने की गारंटी नहीं है, इसलिए यह परिवर्तन मुख्य रूप से ArrayField पर लुकअप के साथ संयोजन के रूप में उपयोग करने के लिए उपयोगी है। SQL फ़ंक्शन akeys() उपयोग करता है। उदाहरण के लिए:

>>> 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'])
<QuerySet [<Dog: Rufus>, <Dog: Meg>]>

values

उन वस्तुओं को लौटाता है जहां मानों का सरणी दिया गया मान है। ध्यान दें कि आदेश विश्वसनीय होने की गारंटी नहीं है, इसलिए यह परिवर्तन मुख्य रूप से ArrayField पर लुकअप के साथ संयोजन के रूप में उपयोग करने के लिए उपयोगी है। SQL फ़ंक्शन avalues() उपयोग करता है। उदाहरण के लिए:

>>> 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'])
<QuerySet [<Dog: Meg>]>

JSONField

class JSONField(encoder=None, **options) [source]

JSON एन्कोडेड डेटा संग्रहीत करने के लिए एक फ़ील्ड। पायथन में डेटा को इसके पायथन देशी प्रारूप में दर्शाया गया है: शब्दकोश, सूचियाँ, तार, संख्या, बूलियन और None ।

encoder

एक वैकल्पिक JSON- एन्कोडिंग वर्ग, मानक JSON धारावाहिक ( datetime , uuid , आदि) द्वारा समर्थित डेटा प्रकारों को क्रमबद्ध करने के लिए नहीं। उदाहरण के लिए, आप DjangoJSONEncoder वर्ग या किसी अन्य json.JSONEncoder उपवर्ग का उपयोग कर सकते हैं।

जब मान डेटाबेस से पुनर्प्राप्त किया जाता है, तो यह कस्टम एनकोडर (सबसे अक्सर एक स्ट्रिंग) द्वारा चुने गए प्रारूप में होगा, इसलिए आपको मूल्य को प्रारंभिक डेटा प्रकार ( Model.from_db() वापस परिवर्तित करने के लिए अतिरिक्त कदम उठाने की आवश्यकता होगी Model.from_db() और Field.from_db_value() उस उद्देश्य के लिए दो संभावित हुक हैं)। आपके deserialization को इस तथ्य के लिए खाते की आवश्यकता हो सकती है कि आप इनपुट प्रकार के बारे में निश्चित नहीं हो सकते हैं। उदाहरण के लिए, आप datetime को वापस करने का जोखिम चलाते हैं जो वास्तव में एक स्ट्रिंग थी जो कि datetime लिए चुने गए एक ही प्रारूप में होती थी।

यदि आप फ़ील्ड को एक default , तो सुनिश्चित करें कि यह एक कॉल करने योग्य है जैसे कि dict (एक खाली डिफ़ॉल्ट के लिए) या एक कॉल करने योग्य जो एक तानाशाही (जैसे कि फ़ंक्शन) लौटाता है। default={} गलत तरीके से default={} का उपयोग करना एक उत्परिवर्ती डिफ़ॉल्ट बनाता है जो JSONField सभी उदाहरणों के बीच साझा किया जाता है।

JSONField

हम निम्नलिखित उदाहरण मॉडल का उपयोग करेंगे:

from django.contrib.postgres.fields import JSONField
from django.db import models

class Dog(models.Model):
    name = models.CharField(max_length=200)
    data = JSONField()

    def __str__(self):
        return self.name

की, इंडेक्स और पाथ लुक्स

किसी दिए गए शब्दकोश कुंजी के आधार पर क्वेरी करने के लिए, उस कुंजी का उपयोग लुकअप नाम के रूप में करें:

>>> Dog.objects.create(name='Rufus', data={
...     'breed': 'labrador',
...     'owner': {
...         'name': 'Bob',
...         'other_pets': [{
...             'name': 'Fishy',
...         }],
...     },
... })
>>> Dog.objects.create(name='Meg', data={'breed': 'collie', 'owner': None})

>>> Dog.objects.filter(data__breed='collie')
<QuerySet [<Dog: Meg>]>

पथ लुकअप बनाने के लिए एकाधिक कुंजियों को एक साथ जंजीर से जोड़ा जा सकता है

>>> Dog.objects.filter(data__owner__name='Bob')
<QuerySet [<Dog: Rufus>]>

यदि कुंजी एक पूर्णांक है, तो इसे एक सरणी में एक इंडेक्स लुकअप के रूप में व्याख्या किया जाएगा:

>>> Dog.objects.filter(data__owner__other_pets__0__name='Fishy')
<QuerySet [<Dog: Rufus>]>

यदि वह कुंजी जिसे आप किसी अन्य लुकअप के नाम के साथ टकराव द्वारा क्वेरी करना चाहते हैं, तो इसके बजाय jsonfield.contains लुकअप का उपयोग करें।

यदि केवल एक कुंजी या इंडेक्स का उपयोग किया जाता है, तो SQL ऑपरेटर -> का उपयोग किया जाता है। यदि कई ऑपरेटरों का उपयोग किया जाता है तो #> ऑपरेटर का उपयोग किया जाता है।

JSON डेटा में null लिए क्वेरी करने के लिए, मान के रूप में None उपयोग करें:

>>> Dog.objects.filter(data__owner=None)
<QuerySet [<Dog: Meg>]>

गुम कुंजियों के लिए क्वेरी करने के लिए, isnull लुकअप का उपयोग करें:

>>> Dog.objects.create(name='Shep', data={'breed': 'collie'})
>>> Dog.objects.filter(data__owner__isnull=True)
<QuerySet [<Dog: Shep>]>

कन्टेनमेंट और प्रमुख संचालन

JSONField साथ नियंत्रण और कुंजियों से संबंधित लुकअप साझा करता है।

• hstorefield.contains (स्ट्रिंग के केवल एक शब्दकोश के बजाय किसी JSON को स्वीकार करता है)
• contained_by (स्ट्रिंग के एक शब्दकोश के बजाय किसी भी JSON स्वीकार करता है)
• has_key
• has_any_keys
• has_keys

रेंज फील्ड्स

पांच रेंज फ़ील्ड प्रकार हैं, जो पोस्टग्रेएसक्यूएल में निर्मित रेंज प्रकारों के अनुरूप हैं। इन क्षेत्रों का उपयोग मूल्यों की एक श्रृंखला को संग्रहीत करने के लिए किया जाता है; उदाहरण के लिए, किसी ईवेंट की शुरुआत और समाप्ति टाइमस्टैम्प्स या एक गतिविधि के लिए उम्र की सीमा उपयुक्त है।

रेंज फ़ील्ड के सभी मानस में psycopg2 श्रेणी की वस्तुओं में अनुवाद करते हैं, लेकिन यह भी इनपुट के रूप में tuples को स्वीकार करते हैं यदि कोई सीमा जानकारी आवश्यक नहीं है। डिफ़ॉल्ट निम्न बाउंड शामिल है, ऊपरी बाउंड बहिष्कृत है; वह है, [) ।

IntegerRangeField

class IntegerRangeField(**options) [source]

पूर्णांकों की एक श्रृंखला को संग्रहीत करता है। एक IntegerField पर आधारित है। डेटाबेस में एक NumericRange और पायथन में एक int4range द्वारा int4range किया गया।

डेटा को सहेजते समय निर्दिष्ट सीमाओं के बावजूद, PostgreSQL हमेशा एक विहित रूप में एक सीमा देता है जिसमें निचला बाउंड शामिल होता है और ऊपरी बाउंड को बाहर करता है; वह [) ।

BigIntegerRangeField

class BigIntegerRangeField(**options) [source]

बड़े पूर्णांक की एक श्रृंखला को संग्रहीत करता है। एक BigIntegerField आधार पर। डेटाबेस में एक NumericRange और Python में एक int8range द्वारा int8range किया गया।

डेटा को सहेजते समय निर्दिष्ट सीमाओं के बावजूद, PostgreSQL हमेशा एक विहित रूप में एक सीमा देता है जिसमें निचला बाउंड शामिल होता है और ऊपरी बाउंड को बाहर करता है; वह [) ।

FloatRangeField

class FloatRangeField(**options) [source]

अस्थायी बिंदु मानों की एक श्रृंखला संग्रहीत करता है। एक FloatField पर आधारित। डेटाबेस में एक NumericRange और पायथन में एक numrange द्वारा numrange किया गया।

DateTimeRangeField

class DateTimeRangeField(**options) [source]

टाइमस्टैम्प की एक श्रृंखला को संग्रहीत करता है। एक DateTimeField आधार पर। डेटाबेस में एक tstzrange और पायथन में एक DateTimeTZRange द्वारा tstzrange किया गया।

DateRangeField

class DateRangeField(**options) [source]

खजूर की एक श्रृंखला संग्रहीत करता है। एक DateField आधार पर। डेटाबेस में एक DateRange और पायथन में एक DateRange द्वारा DateRange गया।

डेटा को सहेजते समय निर्दिष्ट सीमाओं के बावजूद, PostgreSQL हमेशा एक विहित रूप में एक सीमा देता है जिसमें निचला बाउंड शामिल होता है और ऊपरी बाउंड को बाहर करता है; वह [) ।

क्वेरिंग रेंज फील्ड्स

सीमा फ़ील्ड के लिए कई कस्टम लुकअप और ट्रांसफ़ॉर्म हैं। वे उपरोक्त सभी क्षेत्रों में उपलब्ध हैं, लेकिन हम निम्नलिखित उदाहरण मॉडल का उपयोग करेंगे:

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

हम निम्नलिखित उदाहरण वस्तुओं का भी उपयोग करेंगे:

>>> 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))

और NumericRange :

>>> from psycopg2.extras import NumericRange

कंटेनर कार्य करता है

अन्य PostgreSQL क्षेत्रों की तरह, इसमें तीन मानक नियंत्रण ऑपरेटर हैं: क्रमशः, && <@ , <@ , और && का उपयोग करते हुए, contained_by और overlap करते हैं।

contains

>>> Event.objects.filter(ages__contains=NumericRange(4, 5))
<QuerySet [<Event: Soft play>]>

contained_by

>>> Event.objects.filter(ages__contained_by=NumericRange(0, 15))
<QuerySet [<Event: Soft play>]>

IntegerField लुकअप नॉन-रेंज फ़ील्ड प्रकारों पर भी उपलब्ध है: IntegerField , BigIntegerField , FloatField , DateField और DateTimeField । उदाहरण के लिए:

>>> from psycopg2.extras import DateTimeTZRange
>>> Event.objects.filter(start__contained_by=DateTimeTZRange(
...     timezone.now() - datetime.timedelta(hours=1),
...     timezone.now() + datetime.timedelta(hours=1),
... )
<QuerySet [<Event: Soft play>]>

overlap

>>> Event.objects.filter(ages__overlap=NumericRange(8, 12))
<QuerySet [<Event: Soft play>]>

तुलना कार्य

श्रेणी फ़ील्ड मानक लुकअप का समर्थन करते हैं: lt , gt , lte और gte । ये विशेष रूप से सहायक नहीं हैं - वे पहले निचले सीमा की तुलना करते हैं और फिर ऊपरी सीमा केवल यदि आवश्यक हो। यह एक सीमा क्षेत्र द्वारा ऑर्डर करने के लिए उपयोग की जाने वाली रणनीति भी है। विशिष्ट श्रेणी तुलना ऑपरेटरों का उपयोग करना बेहतर है।

fully_lt

वापस की गई सीमाएं उत्तीर्ण सीमा से कड़ाई से कम हैं। दूसरे शब्दों में, लौटी हुई श्रेणी के सभी बिंदु उत्तीर्ण श्रेणी के सभी से कम हैं।

>>> Event.objects.filter(ages__fully_lt=NumericRange(11, 15))
<QuerySet [<Event: Soft play>]>

fully_gt

लौटी हुई सीमाएं उत्तीर्ण सीमा से कड़ाई से अधिक हैं। दूसरे शब्दों में, लौटी हुई श्रेणी के सभी बिंदु उत्तीर्ण श्रेणी के सभी से अधिक हैं।

>>> Event.objects.filter(ages__fully_gt=NumericRange(11, 15))
<QuerySet [<Event: Pub trip>]>

not_lt

लौटी हुई श्रेणियों में उत्तीर्ण सीमा से कम कोई अंक नहीं होता है, अर्थात लौटी हुई सीमा की निचली सीमा कम से कम पारित सीमा से कम होती है।

>>> Event.objects.filter(ages__not_lt=NumericRange(0, 15))
<QuerySet [<Event: Soft play>, <Event: Pub trip>]>

not_gt

लौटी हुई श्रेणियों में उत्तीर्ण सीमा से अधिक कोई अंक नहीं होता है, जो कि लौटी हुई सीमा का ऊपरी भाग पास की सीमा के सबसे ऊपरी भाग पर होता है।

>>> Event.objects.filter(ages__not_gt=NumericRange(3, 10))
<QuerySet [<Event: Soft play>]>

adjacent_to

लौटाई गई सीमाएं पारित सीमा के साथ एक सीमा साझा करती हैं।

>>> Event.objects.filter(ages__adjacent_to=NumericRange(10, 21))
<QuerySet [<Event: Soft play>, <Event: Pub trip>]>

सीमा का उपयोग करके क्वेरी करना

प्रश्नों में उपयोग के लिए तीन परिवर्तन उपलब्ध हैं। आप खाली या ऊपरी बाउंड, या खालीपन के आधार पर क्वेरी निकाल सकते हैं।

startswith

लौटी वस्तुओं में दी गई निचली सीमा होती है। बेस फ़ील्ड के लिए मान्य लुकअप के लिए जंजीर हो सकती है।

>>> Event.objects.filter(ages__startswith=21)
<QuerySet [<Event: Pub trip>]>

endswith

लौटी हुई वस्तुओं में दी गई ऊपरी सीमा होती है। बेस फ़ील्ड के लिए मान्य लुकअप के लिए जंजीर हो सकती है।

>>> Event.objects.filter(ages__endswith=10)
<QuerySet [<Event: Soft play>]>

isempty

लौटी हुई वस्तुएँ खाली श्रेणी हैं। एक BooleanField लिए मान्य लुकअप के लिए जंजीर हो सकती है।

>>> Event.objects.filter(ages__isempty=True)
<QuerySet []>

अपनी खुद की रेंज के प्रकारों को परिभाषित करना

PostgreSQL कस्टम श्रेणी प्रकारों की परिभाषा देता है। Django के मॉडल और फॉर्म फ़ील्ड कार्यान्वयन नीचे बेस कक्षाओं का उपयोग करते हैं, और psycopg2 कस्टम रेंज प्रकारों के उपयोग की अनुमति देने के लिए एक register_range() प्रदान करता है।

class RangeField(**options) [source]

मॉडल रेंज फ़ील्ड के लिए बेस क्लास।

base_field

मॉडल फ़ील्ड वर्ग का उपयोग करने के लिए।

range_type

मानस प्रकार 2 श्रेणी का उपयोग करने के लिए।

form_field

प्रपत्र फ़ील्ड वर्ग का उपयोग करने के लिए। django.contrib.postgres.forms.BaseRangeField उपवर्ग होना चाहिए।

class django.contrib.postgres.forms.BaseRangeField

फार्म रेंज फ़ील्ड के लिए बेस क्लास।

base_field

उपयोग करने के लिए प्रपत्र फ़ील्ड।

range_type

मानस प्रकार 2 श्रेणी का उपयोग करने के लिए।