انواع فیلدها در جنگو

آموزش فیلدها در Django

مهمترین بخش یک مدل، و تنها بخش مورد نیاز آن، لیست فیلد های دیتابیسی است که تعریف میکند. فیلد ها توسط صفت های کلاس مشخص میشوند. توجه کنید که نام فیلد هایی که انتخاب میکنید با models API مانند clean، save و یا delete تداخل نداشته باشد.

مثال :

            class Musician(models.Model):
                first_name = models.CharField(max_length=50)
                last_name = models.CharField(max_length=50)
                instrument = models.CharField(max_length=100)

            class Album(models.Model):
                artist = models.ForeignKey(Musician, on_delete=models.CASCADE)
                name = models.CharField(max_length=100)
                release_date = models.DateField()
                num_stars = models.IntegerField()
                

انواع فیلدها در Django

هر فیلد در مدل شما باید یک instance مناسب از کلاس Filed باشد. Django برای بررسی چند مورد از کلاس field استفاده میکند:

• نوع ستون، که برای دیتابیس مشخص میکند چه نوع داده ای ذخیره کند.( مثلا INTEGER، VARCHAR، TEXT)

• widget پیش فرض برای تفسیر از یک فیلد.( مثلا < input type=”text”>,< select >)

• حداقل اعتبار نیاز مندی ها، که در ادمین Django استفاده میشود و به شکل تولید خورکار است.

Django دارای تعداد زیادی نوع فیلد است که میتوانید لیست کامل آنها را در model field reference مشاهده کنید. اگر نمیتوانید فیلد مورد نیاز خود را در این لیست بیابید، میتوانید به راحتی فیلد های خود را ایجاد کنید. برای این کار Writing custom model fields .

گزینه فیلد در Django

هر فیلد شامل مجموعه مشخصی از ارگومان های مختص فیلد است( که در model field reference ثبت شده است). برای مثال، CharField ( و زیرکلاس های آن) به یک آرگومان max_length نیاز دارند که سایز فیلد VARCHAR دیتا بیسی که برای ذخیره داده استفاده میشود را مشخص میکند.

همچنین مجموعه ای از ارگومان های مشترک نیز برای همه انواع فیلد، موجود است که همه آنها اختیاری هستند و به شکل کاملی در reference توضیح داده شده اند اما خلاصه ای از پرکاربرد ترین های آنها را بررسی میکنیم:

Null

اگر True باشد، Django مقادیر خالی را به عنوان NULL در دیتابیس ذخیره میکند. مقدار پیش فرض False است.

blank

اگر True باشد، فیلد میتواند خالی باشد. مقدار پیش فرض False است.

توجه کنید که این با Null متفاوت است. Null تنها مربوط به دیتابیس است، اما blank با اعتبار سنجی در ارتباط است. اگر در یک فیلد blank=True باشد، ورود یک مقدار خالی معتبر است. اگر مقدار blank=False باشد، مقدار فیلد مورد نیاز است.

choices

یکتوالی از 2-tuples ها به عنوان choice برای این فیلد استفاده میشود. با این کار widget پیش فرض، به جای وارد کردن متن، با انتخاب یک گزینه از گزینه های موجود مشخص میشود که گزینه های ورودی را محدود میکند.

لیست گزینه ها ظاهری شبیه به این دارد:

            YEAR_IN_SCHOOL_CHOICES = [
                   ('FR', 'Freshman'),
                   ('SO', 'Sophomore'),
                   ('JR', 'Junior'),
                   ('SR', 'Senior'),
                   ('GR', 'Graduate'),
                                     ]
                

توجه :

هربار با تغییر ترتیب choice ها، یک migration جدیدی ایجاد میشود.

اولین المان در هر تاپل، مقداری است که در دیتابیس ذخیره میشود. مقدار دوم توسط widget فیلد در فرم نمایش داده میشود.

با داشتن یک مدل نمونه، مقدار یک فیلد مشخص شده با استفاده از choice با متد get_FOO_display() قابل دسترسی است. برای مثال:

            from django.db import models

            class Person(models.Model):
                SHIRT_SIZES = (
                    ('S', 'Small'),
                    ('M', 'Medium'),
                    ('L', 'Large'),
                )
                name = models.CharField(max_length=60)
                shirt_size = models.CharField(max_length=1, choices=SHIRT_SIZES)
                

            >>> p = Person(name="Fred Flintstone", shirt_size="L")
            >>> p.save()
            >>> p.shirt_size
            'L'
            >>> p.get_shirt_size_display()
            'Large'
                

شما همچنین میتوانید برای تعریف مختصر choice ها کلاس ها را شمارش کنید :

            from django.db import models

            class Runner(models.Model):
                MedalType = models.TextChoices('MedalType', 'GOLD SILVER BRONZE')
                name = models.CharField(max_length=60)
                medal = models.CharField(blank=True, choices=MedalType.choices, max_length=10)
                

مثال های بیشتر در model field reference موجود است.

default

مقدار پیش فرض فیلد که میتواند یک مقدار و یا یک شی قابل فراخوانی باشد که با هر بار ایجاد یک شی جدید فراخوانی میشود.

help_text

متن help که با widget نمایش داده میشود که حتی اگر در فرم استفاده نشود برای مستند سازی مفید است.

primary_key

اگر True باشد، این فیلد کلید اصلی برای مدل است.

اگرشما برای هیچ فیلدی primary_key=True قرار ندهید، Django به شکل خودکار یک IntegerField برای نگهداری primary key اضافه میکند، پس اگر نیازی به تغییرپیش فرض primary key ندارید، نیازی به قرار دادن Primary_key=True برای هیچ فیلدی نیست. برای اطلاعات بیشترAutomatic primary key fields را مطالعه کنید.

فیلد primary key ، فقط خواندنی (Read_only) است. اگر مقدار primary key را در یک شی موجود تغییر دهید و سپس آن را ذخیره کنید، شی جدید درکنار شی قبل ایجاد میشود:

            from django.db import models

            class Fruit(models.Model):
                name = models.CharField(max_length=100, primary_key=True)
                

            f>>> fruit = Fruit.objects.create(name='Apple')
            >>> fruit.name = 'Pear'
            >>> fruit.save()
            >>> Fruit.objects.values_list('name', flat=True)
            
                

اگر True قرار داده شود، فیلد باید در کل جدول یکتا (unique) باقی بماند.

دقت کنید که این تنها یک توضیح مختصر برای برخی از گزینه های متداول فیلد ها است. جزئیات کامل را میتوانید در common model field option reference مطالعه کنید.

فیلد های اتوماتیک primary key

به شکل خودکار Django در هر مدل فیلد زیر را قرار میدهد:

            id = models.AutoField(primary_key=True)
                

این یک primary key است که به شکل خودکار افزایش پیدا میکند.

اگر میخواهید یک primary key خاص مشخص کنید، primary_key را برای یکی از فیلد های خود True قرار دهید. زمانی که Django با Field.primary_key مواجه شود، ستون خودکار id را اضافه نخواهد کرد.

هر مدل دقیقا نیازمند یک فیلد است که دارای primary_key=True باشد( که صریحا یا اتوماتیک ایجاد شده باشد ).

نام گویا (verbose) برای فیلد ها

هر نوع فیلد، به جز ForeignKey، ManyToManyField و OneToOneField ، یک ارگومان ابتدایی را به صورت اختیاری به عنوان Verbose name دریافت میکند. اگر Verbose name وجود نداشته باشد، Django به شکل خودکار آن را با استفاده از اولین صفت فیلد، و تبدیل زیر خط ها به فاصله، ایجاد میکند.

در این مثال، نام گویا “person’s first name” میباشد:

            first_name = models.CharField("person's first name", max_length=30)
                

در این مثال، نام گویا “first name” است:

            first_name = models.CharField(max_length=30)
                

برای ForeignKey، ManyToManyFiled و OneToOneField اولین آرگومان، یک کلاس از مدل است، در نتیجه از آرگومان کلیدواژه verbose_name استفاده میشود:

            poll = models.ForeignKey(
                Poll,
                on_delete=models.CASCADE,
                verbose_name="the related poll",
            )
            sites = models.ManyToManyField(Site, verbose_name="list of sites")
            place = models.OneToOneField(
                Place,
                on_delete=models.CASCADE,
                verbose_name="related place",
            )
                

به شکل قرار دادی نیازی به بزرگ نوشتن اولین حرف verbose_name نیست. Django به شکل اتوماتیک درصورت نیاز حرف اول را به حرف بزرگ تغییر میدهد.

رابطه ها

واضح است که برتری دیتا بیس های رابطه ای، ارتباط جداول با یکدیگر است. Django روش هایی برای تعریف سه نوع متداول رابطه های دیتابیس: چند به یک، چند به چند و یک به یک معرفی میکند :

ارتباط چند به یک

برای تعریف یک رابطه چند به یک، از django.db.models.ForeignKey استفاده میشود که میتوانید مانند هر نوع دیگری از Field به عنوان یک صفت در model class خود قرار داده و از آن استفاده کنید.

ForeignKey نیاز به یک آرگومان دارد. آرگومان آن کلاسی است که مدل با آن ارتباط برقرار میکند.

برای مثال، اگر مدل یک Car (ماشین) دارای یک Manufacturer )تولید کننده)باشد، به این معنا که Manufacturer چندین Car میسازد اما یک Car تنها یک Manufacturer دارد، از تعاریف زیر استفاده میشود:

            from django.db import models

            class Manufacturer(models.Model):
                # ...
                pass

            class Car(models.Model):
                manufacturer = models.ForeignKey(Manufacturer, on_delete=models.CASCADE)
                # ...
                

شما همچنین میتوانید روابط بازگشتی (یک شی با رابطه چند به یک با خودش) و یا ایجاد کنید. روابط با مدلی که هنوز تعریف نشدهبرای جزئیات بیشتر the model field reference را مطالعه کنید.

            class Car(models.Model):
                company_that_makes_it = models.ForeignKey(
                    Manufacturer,
                    on_delete=models.CASCADE,
            )
            # ...
                

مطالعه بیشتر :

فیلد های ForeighKey آرگومان های اضافی هم میپذیرند که در the model field reference بررسی شده اند. این گزینه ها به تعریف بهتر روابط کمک میکنند و همگی اختیاری هستند.

برای اطلاعات بیشتر درباره دسترسی به اشیا backwards-related، Following relationships backward example را مطالعه کنید.

برای کد های نمونه بیشتر Many-to-one relationship model example را ببینید.

روابط چند به چند

برای تعریف یک رابطه چند به چند، از ManyToManyFieldاستفاده میشود که میتوانید مانند هر نوع دیگری از Field به عنوان یک صفت در model class خود قرار داده و از آن استفاده کنید.

ManyToManyField نیاز به یک آرگومان دارد. آرگومان آن کلاسی است که مدل با آن ارتباط برقرار میکند.

برای مثال، اگر Pizza دارای چند مدل Toppings (سس ( باشد، به این معنا که Toppings میتواند بر Pizza های مختلفی باشد و هر Pizza چند Toppings داشته باشد، به این شکل نشان داده میشود:

             from django.db import models

             class Topping(models.Model):
                 # ...
                 pass

             class Pizza(models.Model):
                 # ...
                 toppings = models.ManyToManyField(Topping)
                

مانند ForeignKey، شما میتوانید روابط بازگشتی (یک شی که در رابطه چند در چند با خودش است) و روابط با مدلی که هنوز تعریف نشده است نیز، بسازید.

توصیه میشود، اما ضروری نیست، که نام یک ManyTo ManyField (در مثال قبل Toppings) نام جمعی باشد که مجموعه اشیا مرتبط به مدل را تعریف کند.

تفاوتی ندارد که کدام مدل دارای ManyToManyField باشد اما ManyToManyField باید فقط در یکی از مدل ها قرار بگید.

به طور کلی، نمونه های ManyToManyField باید در شی قرار بگیرد که در فرم ویرایش میشوند. در مثال بالا Toppings در Pizza قرار میگیرد( به جای اینکه Topping دارای ManyToManyField برای Pizzas باشد). زیرا فکر کردن به Pizza به شکلی که دارای چندین Toppings باشد معمول تر از عکس آن است. به این شکل که در بالا آورده شده است فرم Pizza به کاربر اجازه میدهد چندین Toppings انتخاب کنند.

ManyToManyFields همچنین تعدادی آرگومان اضافی نیز میپذیرد

فیلد های اضافی در روابط چند به چند

زمانی که فقط با روابط چند به چند، مانند ترکیب پیتزا ها و سس ها، سر و کار دارید، تنها ManyToManyField برای شما کافی است. اما گاهی نیاز است بین داده ها را و روابط بین مدل ها ارتباط برقرار کنید.

برای مثال، اپلیکیشنی را فرض کنید که گروه ها موسیقی که موسیقیدان ها با آنها کار میکنند را دنبال کند. بین افراد و گروه های موسیقی که عضو آن هستند رابطه چند به چند وجود دارد در نتیجه برای نشان دادن این روابط میتوانید از ManyToManyField استفاده کنید، اما اطلاعات زیادی درباره این عضویت وجود دارد که ممکن است برای شما اهمیت داشته باشد. مانند تاریخ شروع عضویت یک فرد در یک گروه.

در این شرایط Django به شما اجازه میدهد مدلی که میخواهید برای مدیریت رابطه ی چند به چند استفاده کنید را مشخص کنید و سپس میتوانید فیلد های بیشتری در مدل میانی) (intermediate قرار دهید.

مدل میانی از طریق آرگومان through با ManyToManyFiled در ارتباط است تا مدلی که به عنوان واسط عمل میکند را مشخص کند. مثال موسیقیدان های ما، کدی شبیه به این دارد:

             from django.db import models

             class Person(models.Model):
                 name = models.CharField(max_length=128)

                 def __str__(self):
                     return self.name

             class Group(models.Model):
                 name = models.CharField(max_length=128)
                 members = models.ManyToManyField(Person, through='Membership')

                 def __str__(self):
                     return self.name

             class Membership(models.Model):
                 person = models.ForeignKey(Person, on_delete=models.CASCADE)
                 group = models.ForeignKey(Group, on_delete=models.CASCADE)
                 date_joined = models.DateField()
                 invite_reason = models.CharField(max_length=64)
                

زمانی که یک مدل میانی ایجاد میکنید، صریحا یک کلید خارجی برای مدل هایی که در رابطه چند به چند هستند مشخص میکنید. این تعریف چگونگی ارتباط دو مدل را مشخص میکند.

چند محدودیت موجود در مدل میانی به شکل زیر است :

• مدل میانی شما باید یک و فقط یک کلید خارجی به source model (در مثال ما Group) داشته باشد و یا شما باید صریحا کلید های خارجی که Django باید برای روابط استفاده کند را به وسیله ی ManyToManyField.through_fields مشخص کنید. اگر شما بیش از یک کلید خارجی داشته باشید و through_fields مشخص نشده باشد، باvalidation error مواجه میشوید. محدودیت مشابهی برای کلید خارجی به مدل هدف target model (در مثال ما Person) نیز وجود دارد.

• برای مدلی که به وسیله ی مدل میانی دارای رابطه چند به چند با خودش است، دو کلید خارجی به یک مدل مجاز است، اما آنها مانند دو طرف متفاوت رابطه چند به چند عمل میکنند. اما اگر بیش از دو کلید خارجی موجود باشد، باید مانند بالا through_fields را مشخص کنید. در غیر این صورت validation error دریافت میکنید.

حالا که برای استفاده از مدل میانی خود، ManyToManyField را مشخص کردید ( که در این مثال عضویت است)، آماده اید که روابط چند به چند ایجاد کنید. این کار را با ایجاد نمونه هایی (instances) از مدل میانی انجام دهید:

             >>> ringo = Person.objects.create(name="Ringo Starr")
             >>> paul = Person.objects.create(name="Paul McCartney")
             >>> beatles = Group.objects.create(name="The Beatles")
             >>> m1 = Membership(person=ringo, group=beatles,
             ...     date_joined=date(1962, 8, 16),
             ...     invite_reason="Needed a new drummer.")
             >>> m1.save()
             >>> beatles.members.all()
             ]>
             >>> ringo.group_set.all()
             ]>
             >>> m2 = Membership.objects.create(person=paul, group=beatles,
             ...     date_joined=date(1960, 8, 1),
             ...     invite_reason="Wanted to form a band.")
             >>> beatles.members.all()
             , ]>
                

همچنین میتوانید از add()، create() و set() نیز برای ایجاد روابط استفاده کنید. اما باید through_defaults را برای هر فیلد مشخص کنید.

            >>> beatles.members.add(john, through_defaults={'date_joined': date(1960, 8, 1)})
            >>> beatles.members.create(name="George Harrison", through_defaults={'date_joined': date(1960, 8, 1)})
            >>> beatles.members.set([john, paul, ringo, george], through_defaults={'date_joined': date(1960, 8, 1)})
                

ممکن بخواهید مسقیما نمونه هایی از مدل میانی ایجاد کنید.

اگر اجباری بر یکتا بودن جفت (model1.model2) در جدول ایجاد شده توسط مدل میانی وجود نداشته باشد، و ایجاد چند مقدار یکسان مجاز باشد، فراخوانی remove() تمام نمونه های مدل میانی را حذف خواهد کرد:

           >>> Membership.objects.create(person=ringo, group=beatles,
           ...     date_joined=date(1968, 9, 4),
           ...     invite_reason="You've been gone for a month and we miss you.")
           >>> beatles.members.all()
           , , ]>
           >>> # This deletes both of the intermediate model instances for Ringo Starr
           >>> beatles.members.remove(ringo)
           >>> beatles.members.all()
           ]>
                

برای حذف تمام روابط چند به چند یک نمونه، میتوان از متد clear() استفاده کرد.

            >>> # Beatles have broken up
            >>> beatles.members.clear()
            >>> # Note that this deletes the intermediate model instances
            >>> Membership.objects.all()
            
                

پس از اینکه روابط چند به چند را ایجاد کردید، میتوانید از query ها استفاده کنید که این کار، مانند روابط چند به چند معمولی، با استفاده از صفت های مدل رابطه چند به چند انجام میشود:

                # Find all the groups with a member whose name starts with 'Paul'
                >>> Group.objects.filter(members__name__startswith='Paul')
                ]>
                    

هم زمان با استفاده از مدل میانی، میتوانید بر صفت های آن query بزنید:

              # Find all the members of the Beatles that joined after 1 Jan 1961
              >>> Person.objects.filter(
              ...     group__name='The Beatles',
              ...     membership__date_joined__gt=date(1961,1,1))
              
                    

اگر نیاز به دسترسی به اطلاعات عضویت دارید میتوانید از query مستقیم بر مدل Membership استفاده کنید:

             >>> ringos_membership = Membership.objects.get(group=beatles, person=ringo)
             >>> ringos_membership.date_joined
             datetime.date(1962, 8, 16)
             >>> ringos_membership.invite_reason
             'Needed a new drummer.'
                    

روش دیگری برای دسترسی به این اطلاعات query زدن رابطه معکوس چند به چند از یک شی person میباشد:

            >>> ringos_membership = ringo.membership_set.get(group=beatles)
            >>> ringos_membership.date_joined
            datetime.date(1962, 8, 16)
            >>> ringos_membership.invite_reason
            'Needed a new drummer.'
                    

روابط یک به یک

برای تعریف یک رابطه یک به یک ازOneToOneField استفاده کنید و مانند هرنوع filed دیگری آن را در صفات یک کلاس در مدل خود قرار دهید.

زمانی که یک شی، شی دیگری را به هر شکلی extend کند، کلید اصلی شی بسیار مفید خواهد بود.

OneToOneField نیاز به یک شی، کلاسی که به آن مرتبط میشود، دارد.

به عنوان مثال، اگر شما قصد داشته باشید یک دیتابیس برای مکان ها “places” بسازید، اطلاعات بسیار معمولی مانند، آدرس، شماره تلفن و.. . را در این دیتابیس استفاده میکنید. حالا اگر پس از ساخت این دیتابیس بخواهید یک دیتابیس دیگر که شامل ستوران ها “Restaurants” میشود بسازید، به جای تکرار دوباره تمام این طلاعات در مدل Restaurants، میتوانید یک OneToOneFiled بین Restaurants و Places ایجاد کنید( زیرا که رستوران، یک مکان است و درواقع برای حل این مسئله شما باید از inheritance استفاده کنید که صریحا دارای رابطه یک به یک است.)

مانند کلید خارجی، میتوان رابطه بازگشتی و ارجاع به مدل هایی که هنوز تعریف نشده اند، نیز تعریف کرد.

فیلد OneToOneField همچنین آرگومان اختیاری parent_link را نیز میپذیرد.

پیش از این کلاس های OneToOneField به شکل خودکار تبدیل به کلید اصلی در یک مدل میشدند اما درحال حاضر این اتفاق نمی افتد( البته شما میتوانید به شکل دستی آرگومان primary_key را pass کنید). درنتیجه میتوانید چند فیلد از نوع OneToOneField در یک مدل داشته باشید.