Django
मॉडल

परिचय

अपना पहला मॉडल बनाना

मॉडल आमतौर पर आपके एप्लिकेशन उपनिर्देशिका के तहत models.py फ़ाइल में परिभाषित किए जाते हैं। django.db.models मॉड्यूल का Model वर्ग आपके मॉडलों को विस्तारित करने के लिए एक अच्छा प्रारंभिक वर्ग है। उदाहरण के लिए:

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.ForeignKey('Author', on_delete=models.CASCADE, related_name='authored_books')
    publish_date = models.DateField(null=True, blank=True)

    def __str__(self): # __unicode__ in python 2.*
        return self.title

मॉडल में प्रत्येक विशेषता डेटाबेस में एक कॉलम का प्रतिनिधित्व करती है।

• title एक पाठ है जिसमें अधिकतम 100 वर्ण हैं
• author एक ForeignKey जो किसी अन्य मॉडल / तालिका के लिए एक संबंध का प्रतिनिधित्व करता है, इस मामले में Author (केवल उदाहरण के प्रयोजनों के लिए उपयोग किया जाता है)। on_delete डेटाबेस को बताता है कि ऑब्जेक्ट के साथ क्या करना है संबंधित ऑब्जेक्ट (एक Author ) को हटा दिया जाना चाहिए। (यह ध्यान दिया जाना चाहिए कि चूंकि django 1.9 on_delete को दूसरे on_delete तर्क के रूप में इस्तेमाल किया जा सकता है। django 2 में यह एक आवश्यक तर्क है और इसे तुरंत इस तरह के रूप में व्यवहार करना उचित है। पुराने संस्करणों में यह CASCADE लिए डिफ़ॉल्ट होगा।)
• publish_date एक तारीख संग्रहीत करता है। null और blank दोनों को यह इंगित करने के लिए True पर सेट किया जाता है कि यह एक आवश्यक फ़ील्ड नहीं है (यानी आप इसे बाद की तारीख में जोड़ सकते हैं या इसे खाली छोड़ सकते हैं।)

विशेषताओं के साथ हम एक विधि को परिभाषित करते हैं __str__ यह पुस्तक का शीर्षक लौटाता है जिसका उपयोग इसके string प्रतिनिधित्व के रूप में किया जाएगा जहां डिफ़ॉल्ट के बजाय आवश्यक है।

डेटाबेस में परिवर्तन लागू करना (माइग्रेशन)

एक नया मॉडल बनाने या मौजूदा मॉडल को संशोधित करने के बाद, आपको अपने परिवर्तनों के लिए माइग्रेशन उत्पन्न करना होगा और फिर निर्दिष्ट डेटाबेस पर माइग्रेशन लागू करना होगा। यह Django के अंतर्निहित माइग्रेशन सिस्टम का उपयोग करके किया जा सकता है। प्रोजेक्ट रूट डाइरेक्टरी में जब manage.py उपयोगिता का उपयोग कर रहे हैं:

python manage.py makemigrations <appname>

उपरोक्त कमांड उन माइग्रेशन स्क्रिप्ट्स को बनाएगी जो आपके एप्लिकेशन के migrations उपनिर्देशिका के तहत आवश्यक हैं। यदि आप <appname> पैरामीटर को छोड़ देते हैं, तो settings.py के INSTALLED_APPS तर्क में परिभाषित सभी एप्लिकेशन संसाधित हो जाएंगे। यदि आपको यह आवश्यक लगता है, तो आप माइग्रेशन संपादित कर सकते हैं।

आप यह जांच सकते हैं कि वास्तव में माइग्रेशन का उपयोग किए बिना माइग्रेशन की आवश्यकता क्या है --dry-run विकल्प, जैसे:

python manage.py makemigrations --dry-run

माइग्रेशन लागू करने के लिए:

python manage.py migrate <appname>

उपरोक्त कमांड पहले चरण में उत्पन्न माइग्रेशन स्क्रिप्ट को निष्पादित करेगा और डेटाबेस को शारीरिक रूप से अपडेट करेगा।

यदि मौजूदा डेटाबेस के मॉडल को बदल दिया जाता है तो आवश्यक परिवर्तन करने के लिए निम्नलिखित कमांड की आवश्यकता होती है।

python manage.py migrate --run-syncdb

Django डिफ़ॉल्ट रूप से <appname>_<classname> नाम से तालिका बनाएगा। कुछ समय के लिए आप इसका उपयोग नहीं करना चाहते हैं। यदि आप डिफ़ॉल्ट नाम बदलना चाहते हैं, तो आप Meta में db_table सेट करके तालिका के नाम की घोषणा कर सकते हैं:

from django.db import models

class YourModel(models.Model):
    parms = models.CharField()
    class Meta:
        db_table = "custom_table_name"

यदि आप यह देखना चाहते हैं कि एक निश्चित माइग्रेशन द्वारा SQL कोड क्या निष्पादित किया जाएगा तो बस इस कमांड को चलाएं:

python manage.py sqlmigrate <app_label> <migration_number>

Django> 1.10
नया makemigrations --check विकल्प गैर-शून्य स्थिति के साथ कमांड से बाहर निकलता है जब माइग्रेशन के बिना मॉडल परिवर्तन का पता लगाया जाता है।

माइग्रेशन पर अधिक जानकारी के लिए माइग्रेशन देखें।

रिश्तों के साथ एक मॉडल बनाना

कई-से-एक रिश्ता

from django.db import models

class Author(models.Model):
   name = models.CharField(max_length=50)

#Book has a foreignkey (many to one) relationship with author
class Book(models.Model):
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    publish_date = models.DateField()

सबसे सामान्य विकल्प। कहीं भी इस्तेमाल किया जा सकता है आप एक रिश्ते का प्रतिनिधित्व करना चाहते हैं

कई-कई रिश्ते

class Topping(models.Model):
    name = models.CharField(max_length=50)

# One pizza can have many toppings and same topping can be on many pizzas
class Pizza(models.Model):
    name = models.CharField(max_length=50)
    toppings = models.ManyToManyField(Topping)

आंतरिक रूप से यह एक अन्य तालिका के माध्यम से दर्शाया गया है। और ManyToManyField को उन मॉडलों पर रखा जाना चाहिए जिन्हें एक फ़ॉर्म पर संपादित किया जाएगा। जैसे: Appointment में एक ManyToManyField नामक Customer , Pizza में Toppings और इतने पर।

कक्षाओं के माध्यम से कई-से-कई संबंध

class Service(models.Model):
     name = models.CharField(max_length=35)

class Client(models.Model):
    name = models.CharField(max_length=35)
    age = models.IntegerField()
    services = models.ManyToManyField(Service, through='Subscription')

class Subscription(models.Model):
     client = models.ForeignKey(Client)
     service = models.ForeignKey(Service)
     subscription_type = models.CharField(max_length=1, choices=SUBSCRIPTION_TYPES)
     created_at = models.DateTimeField(default=timezone.now)

इस तरह, हम वास्तव में दो संस्थाओं के बीच संबंध के बारे में अधिक मेटाडेटा रख सकते हैं। जैसा कि देखा जा सकता है, एक ग्राहक को कई सदस्यता प्रकारों के माध्यम से कई सेवाओं के लिए सदस्यता ली जा सकती है। इस मामले में एकमात्र अंतर यह है कि M2M संबंध में नए उदाहरण जोड़ने के लिए, कोई शॉर्टकट विधि का उपयोग नहीं कर सकता है। pizza.toppings.add(topping) , इसके बजाय, कक्षा के माध्यम से एक नई वस्तु बनाई जानी चाहिए, Subscription.objects.create(client=client, service=service, subscription_type='p')

through tables अन्य भाषाओं में एक JoinColumn , Intersection table या mapping table रूप में भी जाना जाता है

वन-टू-वन रिलेशनशिप

class Employee(models.Model):
   name = models.CharField(max_length=50)
   age = models.IntegerField()
   spouse = models.OneToOneField(Spouse)

class Spouse(models.Model):
   name = models.CharField(max_length=50)

इन फ़ील्ड्स का उपयोग तब करें जब आप केवल दो मॉडलों के बीच एक रचना संबंध रखेंगे।

बेसिक Django DB प्रश्न

Django ORM एक शक्तिशाली अमूर्तता है जो आपको डेटाबेस से डेटा को संग्रहीत करने और पुनर्प्राप्त करने की सुविधा देता है, बिना खुद को एसक्यूएल क्वेरी लिखे।

चलो निम्नलिखित मॉडल मानते हैं:

class Author(models.Model):
   name = models.CharField(max_length=50)

class Book(models.Model): 
   name = models.CharField(max_length=50)
   author = models.ForeignKey(Author)

मान लें कि आपने उपरोक्त कोड को django एप्लिकेशन में जोड़ा है और migrate कमांड चलाएं (ताकि आपका डेटाबेस बन जाए)। द्वारा Django खोल शुरू करो

python manage.py shell

यह मानक अजगर खोल शुरू करता है, लेकिन प्रासंगिक Django पुस्तकालयों के साथ आयात किया जाता है, ताकि आप सीधे महत्वपूर्ण भागों पर ध्यान केंद्रित कर सकें।

उन मॉडलों को आयात करके शुरू करें जिन्हें हमने अभी परिभाषित किया है (मैं मान रहा हूं कि यह एक फ़ाइल मॉडल models.py में किया गया है)

from .models import Book, Author

अपना पहला चयन क्वेरी चलाएँ:

>>> Author.objects.all() 
[]
>>> Book.objects.all()
[]

एक लेखक और पुस्तक वस्तु बनाएँ:

>>> hawking = Author(name="Stephen hawking")
>>> hawking.save()
>>> history_of_time = Book(name="history of time", author=hawking)
>>> history_of_time.save()

या मॉडल ऑब्जेक्ट बनाने और एक लाइन कोड में सहेजने के लिए फ़ंक्शन का उपयोग करें

>>> wings_of_fire = Book.objects.create(name="Wings of Fire", author="APJ Abdul Kalam")

अब क्वेरी चलाते हैं

>>> Book.objects.all()
[<Book: Book object>]
>>> book = Book.objects.first() #getting the first book object
>>> book.name
u'history of time'

चलिए हमारे चयन क्वेरी में एक क्लॉज़ जोड़ते हैं

>>> Book.objects.filter(name='nothing')
[]
>>> Author.objects.filter(name__startswith='Ste')
[<Author: Author object>]

किसी पुस्तक के लेखक के बारे में विवरण प्राप्त करने के लिए

>>> book = Book.objects.first() #getting the first book object
>>> book.author.name # lookup on related model
u'Stephen hawking'

स्टीफन हॉकिंग द्वारा प्रकाशित सभी पुस्तकों को प्राप्त करने के लिए (इसके लेखक द्वारा लुकअप पुस्तक)

>>> hawking.book_set.all()
[<Book: Book object>]

_set "रिवर्स लुकअप" के लिए उपयोग किया जाने वाला नोटेशन है, जबकि लुकअप फ़ील्ड बुक मॉडल पर है, हम अपनी सभी पुस्तकों को प्राप्त करने के लिए एक लेखक ऑब्जेक्ट पर book_set उपयोग कर सकते हैं।

एक बुनियादी अप्रबंधित तालिका।

Django के अपने उपयोग के कुछ बिंदु पर, आप अपने आप को उन तालिकाओं के साथ बातचीत करना चाह सकते हैं जो पहले ही बनाई गई हैं, या डेटाबेस विचारों के साथ। इन मामलों में, आप नहीं चाहेंगे कि Django अपने माइग्रेशन के माध्यम से तालिकाओं का प्रबंधन करे। इसे सेट करने के लिए, आपको अपने मॉडल के Meta वर्ग में केवल एक चर जोड़ना होगा: managed = False ।

यहाँ एक उदाहरण है कि आप डेटाबेस दृश्य के साथ बातचीत करने के लिए एक अप्रबंधित मॉडल कैसे बना सकते हैं:

class Dummy(models.Model):
    something = models.IntegerField()

    class Meta:
       managed = False

निम्नानुसार SQL में परिभाषित दृश्य में मैप किया जा सकता है।

CREATE VIEW myapp_dummy AS 
SELECT id, something FROM complicated_table 
WHERE some_complicated_condition = True

एक बार जब आप इस मॉडल को बना लेते हैं, तो आप इसे किसी अन्य मॉडल के रूप में उपयोग कर सकते हैं:

>>> Dummy.objects.all()
[<Dummy: Dummy object>, <Dummy: Dummy object>, <Dummy: Dummy object>]
>>> Dummy.objects.filter(something=42)
[<Dummy: Dummy object>]

उन्नत मॉडल

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

from django.db import models
from django.urls import reverse
from django.utils.encoding import python_2_unicode_compatible

@python_2_unicode_compatible
class Book(models.Model):
    slug = models.SlugField()
    title = models.CharField(max_length=128)
    publish_date = models.DateField()

    def get_absolute_url(self):
        return reverse('library:book', kwargs={'pk':self.pk})

    def __str__(self):
        return self.title

    class Meta:
        ordering = ['publish_date', 'title']

स्वचालित प्राथमिक कुंजी

आप get_absolute_url विधि में self.pk के उपयोग को देख सकते हैं। pk क्षेत्र एक मॉडल की प्राथमिक कुंजी के लिए एक उपनाम है। इसके अलावा, अगर यह गायब है तो django अपने आप एक प्राथमिक कुंजी जोड़ देगा। यह चिंता करने की एक कम बात है और आप किसी भी मॉडल के लिए विदेशी कुंजी सेट करते हैं और उन्हें आसानी से प्राप्त करते हैं।

पूर्ण url

पहला कार्य जो परिभाषित किया गया है get_absolute_url है get_absolute_url । इस तरह, यदि आपके पास कोई पुस्तक है, तो आप url टैग, रिज़ॉल्यूशन, विशेषता और इस तरह से फ़िदेलिंग के बिना एक लिंक प्राप्त कर सकते हैं। बस book.get_absolute_url कॉल करें और आपको सही लिंक मिले। एक बोनस के रूप में, django व्यवस्थापक में आपकी वस्तु "साइट पर दृश्य" बटन प्राप्त करेगी।

स्ट्रिंग प्रतिनिधित्व

जब आपको इसे प्रदर्शित करने की आवश्यकता हो तो एक __str__ विधि का उपयोग करें। उदाहरण के लिए, पिछली पद्धति के साथ, टेम्प्लेट में पुस्तक के लिए लिंक जोड़ना उतना ही सरल है, जितना <a href="{{ book.get_absolute_url }}">{{ book }}</a> सीधा मुद्दे पर। उदाहरण के लिए विदेशी कुंजी के लिए व्यवस्थापक ड्रॉप-डाउन में प्रदर्शित की गई यह विधि भी नियंत्रित करती है।

वर्ग डेकोरेटर आप एक बार दोनों के लिए विधि को परिभाषित करते हैं __str__ और __unicode__ आप अपने अनुप्रयोग दोनों संस्करण, जाने के लिए रास्ता नहीं है कि पर चलने की उम्मीद है, जबकि अजगर 3. पर कोई समस्या पैदा कर अजगर 2 पर।

स्लग क्षेत्र

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

मेटा क्लास

Meta क्लास हमें आइटम के पूरे संग्रह पर बहुत अधिक जानकारी परिभाषित करने देती है। यहां, केवल डिफ़ॉल्ट ऑर्डर सेट किया गया है। यह उदाहरण के लिए ListView ऑब्जेक्ट के साथ उपयोगी है। यह छँटाई के लिए उपयोग करने के लिए क्षेत्र की एक आदर्श रूप से छोटी सूची लेता है। यहाँ, पुस्तक को पहले प्रकाशन की तारीख से छाँटा जाएगा, फिर शीर्षक से अगर तारीख समान होगी।

अन्य verbose_name विशेषताएँ verbose_name और verbose_name_plural । डिफ़ॉल्ट रूप से, वे मॉडल के नाम से उत्पन्न होते हैं और ठीक होना चाहिए। लेकिन बहुवचन रूप भोला है, बस एक 's' को एकवचन में जोड़ना ताकि आप इसे किसी मामले में स्पष्ट रूप से सेट करना चाहें।

कंप्यूटेड वैल्यूज़

एक बार जब कोई मॉडल ऑब्जेक्ट प्राप्त किया जाता है, तो यह कक्षा का पूरी तरह से एहसास हो जाता है। जैसे, किसी भी अतिरिक्त तरीकों को रूपों और धारावाहिकों (जैसे Django रेस्ट फ्रेमवर्क) में एक्सेस किया जा सकता है।

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

def expire():
    return timezone.now() + timezone.timedelta(days=7)

class Coupon(models.Model):
    expiration_date = models.DateField(default=expire)

    @property
    def is_expired(self):
        return timezone.now() > self.expiration_date

अधिकांश मामलों में आप अपने क्वेरीज़ पर एनोटेशन के साथ डेटा को पूरक कर सकते हैं, परिकलित मान मॉडल गुणों के रूप में गणना के लिए आदर्श होते हैं जिनका मूल्यांकन केवल एक क्वेरी के दायरे में नहीं किया जा सकता है।

इसके अतिरिक्त, गुण, चूंकि उन्हें अजगर वर्ग पर घोषित किया गया है और स्कीमा के हिस्से के रूप में नहीं, उनके खिलाफ क्वेरी करने के लिए उपलब्ध नहीं हैं।

एक मॉडल का एक स्ट्रिंग प्रतिनिधित्व जोड़ना

एक मॉडल ऑब्जेक्ट की मानव-पठनीय प्रस्तुति बनाने के लिए आपको Model.__str__() विधि (या Model.__unicode__() python2 पर Model.__unicode__() लागू करने की आवश्यकता है। जब भी आप अपने मॉडल (उदाहरण के लिए, जब किसी टेम्पलेट में मॉडल का उपयोग किया जाता है str() उदाहरण पर str() कॉल करते हैं तो यह विधि str() । यहाँ एक उदाहरण है:

1. एक पुस्तक मॉडल बनाएं।

   # your_app/models.py
   
   from django.db import models
   
   class Book(models.Model):
       name = models.CharField(max_length=50)
       author = models.CharField(max_length=50)
   

2. मॉडल का एक उदाहरण बनाएं, और इसे डेटाबेस में सहेजें:

   >>> himu_book = Book(name='Himu Mama', author='Humayun Ahmed')
   >>> himu_book.save()
   

3. उदाहरण पर print() निष्पादित करें:

   >>> print(himu_book)
   <Book: Book object>
   

<Book: पुस्तक ऑब्जेक्ट> , डिफ़ॉल्ट आउटपुट, हमारी कोई मदद नहीं करता है। इसे ठीक करने के लिए, एक __str__ विधि जोड़ें।

from django.utils.encoding import python_2_unicode_compatible

@python_2_unicode_compatible
class Book(models.Model):
    name = models.CharField(max_length=50)
    author = models.CharField(max_length=50)

    def __str__(self):
        return '{} by {}'.format(self.name, self.author)

नोट python_2_unicode_compatible डेकोरेटर की जरूरत है केवल अगर आप अपने कोड अजगर 2. इस डेकोरेटर प्रतियों के साथ संगत होना चाहता हूँ __str__ विधि एक बनाने के लिए __unicode__ विधि। इसे django.utils.encoding से आयात करें।

अब अगर हम प्रिंट फंक्शन को पुस्तक के उदाहरण के रूप में फिर से कहते हैं:

>>> print(himu_book)
Himu Mama by Humayun Ahmed

काफी बेहतर!

स्ट्रिंग प्रतिनिधित्व का उपयोग तब भी किया जाता है जब मॉडल का उपयोग ForeignKeyField और ManyToManyField क्षेत्रों के लिए एक ModelForm में किया जाता है।

मॉडल मिश्रण

एक ही मामले में विभिन्न मॉडलों में उत्पाद जीवन चक्र में समान क्षेत्र और समान प्रक्रियाएं हो सकती हैं। कोड पुनरावृत्ति विरासत के बिना इन समानताओं को संभालने के लिए इस्तेमाल किया जा सकता है। पूरी कक्षा को विरासत में देने के बजाय, मिक्सिन डिज़ाइन पैटर्न हमें विरासत ( या कुछ का कहना है ) कुछ तरीकों और विशेषताओं को प्रदान करता है। आइए एक उदाहरण देखें:

class PostableMixin(models.Model):
    class Meta:
        abstract=True
    
    sender_name = models.CharField(max_length=128)
    sender_address = models.CharField(max_length=255)
    receiver_name = models.CharField(max_length=128)
    receiver_address = models.CharField(max_length=255)
    post_datetime = models.DateTimeField(auto_now_add=True)
    delivery_datetime = models.DateTimeField(null=True)
    notes = models.TextField(max_length=500)

class Envelope(PostableMixin):
    ENVELOPE_COMMERCIAL = 1
    ENVELOPE_BOOKLET = 2
    ENVELOPE_CATALOG = 3

    ENVELOPE_TYPES = (
        (ENVELOPE_COMMERCIAL, 'Commercial'),
        (ENVELOPE_BOOKLET, 'Booklet'),
        (ENVELOPE_CATALOG, 'Catalog'),
    )

    envelope_type = models.PositiveSmallIntegerField(choices=ENVELOPE_TYPES)

class Package(PostableMixin):
    weight = models.DecimalField(max_digits=6, decimal_places=2)
    width = models.DecimalField(max_digits=5, decimal_places=2)
    height = models.DecimalField(max_digits=5, decimal_places=2)
    depth = models.DecimalField(max_digits=5, decimal_places=2)

किसी मॉडल को अमूर्त वर्ग में बदलने के लिए, आपको इसके आंतरिक Meta क्लास में abstract=True का उल्लेख करना होगा। Django डेटाबेस में सार मॉडल के लिए कोई तालिका नहीं बनाता है। हालांकि मॉडल Envelope और Package , डेटाबेस में संबंधित तालिकाओं का निर्माण किया जाएगा।

इसके अलावा खेतों में कुछ मॉडल विधियों की आवश्यकता होगी एक से अधिक मॉडल। इस प्रकार कोड पुनरावृत्ति को रोकने के लिए इन तरीकों को मिक्सिन्स में जोड़ा जा सकता है। उदाहरण के लिए, यदि हम PostableMixin को डिलीवरी की तारीख निर्धारित करने के लिए एक विधि बनाते हैं तो यह उसके दोनों बच्चों में से एक होगी।

class PostableMixin(models.Model):
    class Meta:
        abstract=True

    ...
    ...

    def set_delivery_datetime(self, dt=None):
        if dt is None:
            from django.utils.timezone import now
            dt = now()

        self.delivery_datetime = dt
        self.save()

इस पद्धति का उपयोग बच्चों पर निम्नलिखित के रूप में किया जा सकता है:

>> envelope = Envelope.objects.get(pk=1)
>> envelope.set_delivery_datetime()

>> pack = Package.objects.get(pk=1)
>> pack.set_delivery_datetime()

UUID प्राथमिक कुंजी

डिफ़ॉल्ट रूप से एक मॉडल एक ऑटो इंक्रीमेंट (पूर्णांक) प्राथमिक कुंजी का उपयोग करेगा। यह आपको चाबियाँ 1, 2, 3 का अनुक्रम देगा।

मॉडल में छोटे बदलाव के साथ एक मॉडल पर विभिन्न प्राथमिक कुंजी प्रकार सेट किए जा सकते हैं।

एक यूयूआईडी एक सार्वभौमिक रूप से विशिष्ट पहचानकर्ता है, यह 32 अक्षर का यादृच्छिक पहचानकर्ता है जिसे आईडी के रूप में इस्तेमाल किया जा सकता है। यह तब उपयोग करने का एक अच्छा विकल्प है जब आप अनुक्रमिक आईडी को अपने डेटाबेस में रिकॉर्ड करने के लिए असाइन नहीं करना चाहते हैं। जब PostgreSQL पर उपयोग किया जाता है, यह एक uuid डेटाटाइप में संग्रहीत होता है, अन्यथा एक चार्ट (32) में।

import uuid
from django.db import models

class ModelUsingUUID(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)

उत्पन्न कुंजी प्रारूप 7778c552-73fc-4bc4-8bf9-5a2f6f7b7f47

विरासत

दो तरीकों से किया जा सकता है:

• एक सामान्य सार वर्ग ("मॉडल मिश्रण" उदाहरण देखें)
• कई तालिकाओं के साथ एक सामान्य मॉडल

मल्टी टेबल इनहेरिटेंस सामान्य फ़ील्ड के लिए एक टेबल बनाएगा और एक प्रति बच्चा मॉडल उदाहरण:

from django.db import models

class Place(models.Model):
    name = models.CharField(max_length=50)
    address = models.CharField(max_length=80)

class Restaurant(Place):
    serves_hot_dogs = models.BooleanField(default=False)
    serves_pizza = models.BooleanField(default=False)

2 टेबल बनाएंगे, एक Place और एक Restaurant के लिए एक छिपे हुए OneToOne फील्ड के साथ आम फील्ड्स के लिए Place लिए।

ध्यान दें कि इसके लिए हर बार जब आप एक रेस्त्रां ऑब्जेक्ट लाते हैं, तो टेबल के लिए एक अतिरिक्त क्वेरी की आवश्यकता होगी।