เมื่อเราเพิ่มฟิลด์ฐานข้อมูลใน django เรามักจะเขียน:

models.CharField(max_length=100, null=True, blank=True)

เช่นเดียวกับที่ทำกับForeignKey, DecimalFieldฯลฯ คืออะไรแตกต่างขั้นพื้นฐานในการมี

  1. null=True เท่านั้น
  2. blank=True เท่านั้น
  3. null=True, blank=True

ในส่วนที่เกี่ยวกับฟิลด์ต่างๆ( CharField, ForeignKey, ManyToManyField, DateTimeField) ข้อดี/ข้อเสียของการใช้ 1/2/3 คืออะไร?

ตอบ

null=Trueตั้งค่าNULL(เทียบกับNOT NULL) บนคอลัมน์ในฐานข้อมูลของคุณ ค่าว่างสำหรับประเภทฟิลด์ Django เช่นDateTimeFieldหรือForeignKeyจะถูกเก็บไว้NULLในฐานข้อมูล

blankกำหนดว่าฟิลด์จะต้องอยู่ในแบบฟอร์มหรือไม่ ซึ่งรวมถึงผู้ดูแลระบบและแบบฟอร์มที่คุณกำหนดเอง ถ้าเป็นเช่นblank=Trueนั้นฟิลด์จะไม่จำเป็น ในขณะที่ถ้าเป็นFalseฟิลด์ไม่สามารถเว้นว่างได้

คอมโบของทั้งสองใช้บ่อยมาก เนื่องจากโดยทั่วไปแล้ว ถ้าคุณจะยอมให้ฟิลด์ว่างในฟอร์มของคุณ คุณจะต้องใช้ฐานข้อมูลของคุณเพื่ออนุญาตNULLค่าสำหรับฟิลด์นั้น ข้อยกเว้นคือCharFields และTextFields ซึ่งใน Django จะไม่ถูกบันทึกเป็นNULL. ค่าว่างจะถูกเก็บไว้ในฐานข้อมูลเป็นสตริงว่าง ( '')

ตัวอย่างบางส่วน:

models.DateTimeField(blank=True) # raises IntegrityError if blank

models.DateTimeField(null=True) # NULL allowed, but must be filled out in a form

เห็นได้ชัดว่า สองตัวเลือกนี้ไม่สมเหตุสมผลที่จะใช้ (แม้ว่าอาจมีกรณีการใช้งานnull=True, blank=Falseหากคุณต้องการให้ฟิลด์จำเป็นเสมอในแบบฟอร์ม เป็นทางเลือกเมื่อจัดการกับวัตถุผ่านบางอย่างเช่นเชลล์)

models.CharField(blank=True) # No problem, blank is stored as ''

models.CharField(null=True) # NULL allowed, but will never be set as NULL

CHARและTEXTประเภทจะไม่ถูกบันทึกNULLโดย Django ดังนั้นจึงnull=Trueไม่จำเป็น อย่างไรก็ตามคุณสามารถตั้งค่าด้วยตนเองหนึ่งฟิลด์เหล่านี้เพื่อที่จะมีผลบังคับใช้ตั้งเป็นNone NULLหากคุณมีสถานการณ์ที่อาจจำเป็น คุณยังคงควรรวมnull=True.

นี่คือวิธีที่ ORM แมปblank& nullฟิลด์สำหรับ Django 1.8

class Test(models.Model):
    charNull        = models.CharField(max_length=10, null=True)
    charBlank       = models.CharField(max_length=10, blank=True)
    charNullBlank   = models.CharField(max_length=10, null=True, blank=True)

    intNull         = models.IntegerField(null=True)
    intBlank        = models.IntegerField(blank=True)
    intNullBlank    = models.IntegerField(null=True, blank=True)

    dateNull        = models.DateTimeField(null=True)
    dateBlank       = models.DateTimeField(blank=True)
    dateNullBlank   = models.DateTimeField(null=True, blank=True)        

ฟิลด์ฐานข้อมูลที่สร้างขึ้นสำหรับPostgreSQL 9.4คือ:

CREATE TABLE Test (
  id              serial                    NOT NULL,

  "charNull"      character varying(10),
  "charBlank"     character varying(10)     NOT NULL,
  "charNullBlank" character varying(10),

  "intNull"       integer,
  "intBlank"      integer                   NOT NULL,
  "intNullBlank"  integer,

  "dateNull"      timestamp with time zone,
  "dateBlank"     timestamp with time zone  NOT NULL,
  "dateNullBlank" timestamp with time zone,
  CONSTRAINT Test_pkey PRIMARY KEY (id)
)

ฟิลด์ฐานข้อมูลที่สร้างขึ้นสำหรับMySQL 5.6คือ:

CREATE TABLE Test (
     `id`            INT(11)     NOT  NULL    AUTO_INCREMENT,

     `charNull`      VARCHAR(10) NULL DEFAULT NULL,
     `charBlank`     VARCHAR(10) NOT  NULL,
     `charNullBlank` VARCHAR(10) NULL DEFAULT NULL,

     `intNull`       INT(11)     NULL DEFAULT NULL,
     `intBlank`      INT(11)     NOT  NULL,
     `intNullBlank`  INT(11)     NULL DEFAULT NULL,

     `dateNull`      DATETIME    NULL DEFAULT NULL,
     `dateBlank`     DATETIME    NOT  NULL,
     `dateNullBlank` DATETIME    NULL DEFAULT NULL
)

สิ่งสำคัญคือต้องเข้าใจว่าตัวเลือกในข้อกำหนดฟิลด์โมเดล Django มีจุดประสงค์สองประการ (อย่างน้อย) ได้แก่ การกำหนดตารางฐานข้อมูล และการกำหนดรูปแบบเริ่มต้นและการตรวจสอบความถูกต้องของฟอร์มโมเดล (ฉันพูดว่า "ค่าเริ่มต้น" เพราะค่าสามารถถูกแทนที่ได้เสมอโดยการระบุฟอร์มที่กำหนดเอง) บางตัวเลือกมีผลกับฐานข้อมูล บางตัวเลือกมีผลกับแบบฟอร์ม และบางส่วนมีผลกับทั้งสองอย่าง

เมื่อพูดถึงnullและblankคำตอบอื่น ๆ ได้แสดงไว้อย่างชัดเจนแล้วว่า คำตอบเดิมมีผลต่อการกำหนดตารางฐานข้อมูล และคำตอบหลังส่งผลต่อการตรวจสอบความถูกต้องของโมเดล ฉันคิดว่าสามารถแยกแยะความแตกต่างได้ชัดเจนยิ่งขึ้นโดยดูจากกรณีการใช้งานสำหรับการกำหนดค่าที่เป็นไปได้ทั้งหมดสี่แบบ:

  • null=False, blank=False: นี่คือการกำหนดค่าเริ่มต้นและหมายความว่าจำเป็นต้องมีค่าในทุกสถานการณ์

  • null=True, blank=True: หมายความว่าฟิลด์นี้เป็นทางเลือกในทุกสถานการณ์ (ตามที่ระบุไว้ด้านล่าง นี่ไม่ใช่วิธีที่แนะนำในการทำให้ฟิลด์แบบสตริงเป็นตัวเลือก)

  • null=False, blank=True: หมายความว่าแบบฟอร์มไม่ต้องการค่า แต่ฐานข้อมูลไม่ต้องการ มีหลายกรณีการใช้งานสำหรับสิ่งนี้:

    • การใช้งานทั่วไปส่วนใหญ่ใช้สำหรับฟิลด์แบบสตริงที่เป็นตัวเลือก ตามที่ระบุไว้ในเอกสารสำนวน Django คือการใช้สตริงว่างเพื่อระบุค่าที่ขาดหายไป หากNULLได้รับอนุญาต คุณจะจบลงด้วยสองวิธีที่แตกต่างกันเพื่อระบุค่าที่ขาดหายไป

    • สถานการณ์ทั่วไปอีกประการหนึ่งคือ คุณต้องการคำนวณฟิลด์หนึ่งโดยอัตโนมัติตามค่าของฟิลด์อื่น (ในsave()วิธีการของคุณพูด) คุณไม่ต้องการให้ผู้ใช้ระบุค่าในรูปแบบ (ด้วยเหตุนี้blank=True) แต่คุณต้องการให้ฐานข้อมูลบังคับให้มีการระบุค่าเสมอ ( null=False)

    • การใช้งานอีกอย่างคือเมื่อคุณต้องการระบุว่า a ManyToManyFieldเป็นทางเลือก เพราะข้อมูลนี้จะถูกนำมาใช้เป็นตารางแยกมากกว่าคอลัมน์ฐานข้อมูลที่มีความหมายnull ค่าของblankwill ยังคงส่งผลต่อฟอร์ม แม้ว่าจะควบคุมว่าการตรวจสอบความถูกต้องจะสำเร็จหรือไม่เมื่อไม่มีความสัมพันธ์

  • null=True, blank=False: หมายความว่าแบบฟอร์มต้องการค่า แต่ฐานข้อมูลไม่ต้องการ นี่อาจเป็นการกำหนดค่าที่ใช้ไม่บ่อยที่สุด แต่มีบางกรณีการใช้งานสำหรับการกำหนดค่านี้:

    • สมเหตุสมผลอย่างยิ่งที่จะกำหนดให้ผู้ใช้ของคุณใส่ค่าเสมอ แม้ว่าตรรกะทางธุรกิจของคุณจะไม่จำเป็นก็ตาม ท้ายที่สุด แบบฟอร์มเป็นเพียงวิธีหนึ่งในการเพิ่มและแก้ไขข้อมูล คุณอาจมีโค้ดที่สร้างข้อมูลซึ่งไม่ต้องการการตรวจสอบที่เข้มงวดแบบเดียวกับที่คุณต้องการให้โปรแกรมแก้ไขที่เป็นมนุษย์กำหนด

    • กรณีการใช้งานอื่น ๆ ที่ผมเคยเห็นคือเมื่อคุณมีForeignKeyที่คุณไม่ต้องการที่จะช่วยให้การลบน้ำตก นั่นคือ ในการใช้งานปกติ ความสัมพันธ์ควรอยู่ที่นั่นเสมอ ( blank=False) แต่ถ้าสิ่งที่ชี้ให้เห็นถูกลบ คุณไม่ต้องการให้วัตถุนี้ถูกลบด้วย ในกรณีที่คุณสามารถใช้null=Trueและon_delete=models.SET_NULLจะใช้ชนิดที่เรียบง่ายของการลบนุ่ม

ตามที่กล่าวไว้ในการอ้างอิงภาคสนาม Django Model: Link

Field options

The following arguments are available to all field types. All are optional.


null

Field.null

If True, Django will store empty values as NULL in the database. Default is False.

Avoid using null on string-based fields such as CharField and TextField because empty string values will always be stored as empty strings, not as NULL. If a string-based field has null=True, that means it has two possible values for "no data": NULL, and the empty string. In most cases, it’s redundant to have two possible values for "no data"; the Django convention is to use the empty string, not NULL.

For both string-based and non-string-based fields, you will also need to set blank=True if you wish to permit empty values in forms, as the null parameter only affects database storage (see blank).

Note

When using the Oracle database backend, the value NULL will be stored to denote the empty string regardless of this attribute


blank

Field.blank

If True, the field is allowed to be blank. Default is False.

Note that this is different than null. null is purely database-related, whereas blank is validation-related. If a field has blank=True, form validation will allow entry of an empty value. If a field has blank=False, the field will be required.

คุณอาจมีคำตอบของคุณ อย่างไรก็ตาม จนถึงวันนี้ ก็ยังยากที่จะตัดสินว่าจะใส่ null=True หรือ blank=True หรือทั้งสองอย่างลงในฟิลด์ โดยส่วนตัวแล้วฉันคิดว่ามันไม่มีประโยชน์และสับสนมากที่จะให้ตัวเลือกมากมายแก่นักพัฒนา ให้จัดการค่าว่างหรือช่องว่างตามต้องการ

ฉันติดตามตารางนี้จากTwo Scoops of Django :ใส่คำอธิบายภาพที่นี่

ตารางแสดงเวลาที่จะใช้ค่าว่างหรือค่าว่างสำหรับแต่ละประเภทฟิลด์

เพียงแค่null=Trueกำหนดฐานข้อมูลควรยอมรับNULLค่า ในทางกลับกันblank=Trueกำหนดการตรวจสอบแบบฟอร์ม ฟิลด์นี้ควรยอมรับค่าว่างหรือไม่ (หากblank=Trueยอมรับแบบฟอร์มที่ไม่มีค่าในฟิลด์นั้นและblank=False[ค่าเริ่มต้น] ในการตรวจสอบแบบฟอร์ม จะแสดงฟิลด์นี้ จำเป็นต้องมีข้อผิดพลาด

null=True/False ที่เกี่ยวข้องกับฐานข้อมูล

blank=True/False ที่เกี่ยวข้องกับการตรวจสอบแบบฟอร์ม

นี่คือตัวอย่างฟิลด์ที่มีblank= Trueandnull=True

description = models.TextField(blank=True, null= True)

ในกรณีนี้: blank = True: บอกแบบฟอร์มของเราว่าสามารถเว้นช่องคำอธิบายว่างไว้ได้

และ

null = True: บอกฐานข้อมูลของเราว่าสามารถบันทึกค่า null ในฟิลด์ db ของเราได้ และจะไม่ทำให้เกิดข้อผิดพลาด

ถ้าคุณตั้งค่าก็จะช่วยให้ค่าของคอลัมน์ฐานข้อมูลของคุณจะได้รับการกำหนดให้เป็นnull=True NULLถ้าคุณตั้งค่าเพียงblank=True, Django ""จะตั้งค่าใหม่เริ่มต้นสำหรับคอลัมน์เท่ากับ

มีจุดหนึ่งที่null=Trueจำเป็นแม้กระทั่งใน a CharFieldหรือTextFieldและนั่นคือเมื่อฐานข้อมูลมีการuniqueตั้งค่าสถานะสำหรับคอลัมน์ ในกรณีนี้ คุณจะต้องใช้สิ่งนี้:

a_unique_string = models.CharField(blank=True, null=True, unique=True)

ควรข้ามnull=Truefor non-unique CharFieldหรือTextField. มิฉะนั้น บางฟิลด์จะถูกตั้งค่าเป็นNULLขณะที่บางฟิลด์เป็น""และคุณจะต้องตรวจสอบค่าของฟิลด์NULLทุกครั้ง

ค่าเริ่มต้นของค่าว่างและค่าว่างเป็นเท็จ

Null: เกี่ยวข้องกับฐานข้อมูล กำหนดว่าคอลัมน์ฐานข้อมูลที่กำหนดจะยอมรับค่า null หรือไม่

ว่างเปล่า: เกี่ยวข้องกับการตรวจสอบความถูกต้อง จะใช้ในระหว่างการตรวจสอบแบบฟอร์ม เมื่อเรียก form.is_valid()

ดังที่กล่าวไปแล้ว เป็นเรื่องปกติที่จะมีฟิลด์ที่มี null=True และ blank=False ความหมายในระดับฐานข้อมูล ฟิลด์สามารถเป็น NULL ได้ แต่ในระดับแอปพลิเคชัน ฟิลด์บังคับเป็นฟิลด์บังคับ

ตอนนี้ นักพัฒนาส่วนใหญ่เข้าใจผิด: การกำหนด null=True สำหรับฟิลด์ที่ใช้สตริง เช่น CharField และ TextField หลีกเลี่ยงการทำอย่างนั้น มิฉะนั้น คุณจะลงเอยด้วยค่าที่เป็นไปได้สองค่าสำหรับ "ไม่มีข้อมูล" นั่นคือ: ไม่มีและสตริงว่าง มีค่าที่เป็นไปได้สองค่าสำหรับ "ไม่มีข้อมูล" ซ้ำซ้อน แบบแผนของ Django คือการใช้สตริงว่าง ไม่ใช่ NULL

null = True

หมายความว่าไม่มีข้อจำกัดของฐานข้อมูลสำหรับฟิลด์ที่จะเติม ดังนั้นคุณสามารถมีอ็อบเจ็กต์ที่มีค่า null สำหรับการกรอกข้อมูลที่มีตัวเลือกนี้

blank = True

หมายความว่าไม่มีข้อจำกัดของการตรวจสอบในรูปแบบ django ดังนั้นเมื่อคุณกรอก a modelFormสำหรับโมเดลนี้ คุณสามารถปล่อยให้ฟิลด์นี้ไม่มีตัวเลือกนี้

นี่คือความแตกต่างหลักของnull=Trueและblank=True:

ค่าเริ่มต้นของทั้งคู่nullและblankเป็นเท็จ ค่าทั้งสองนี้ทำงานที่ระดับฟิลด์ นั่นคือ ไม่ว่าเราต้องการเก็บฟิลด์nullหรือblank.

null=Trueจะตั้งค่าฟิลด์เป็นNULLเช่นไม่มีข้อมูล เป็นพื้นฐานสำหรับค่าคอลัมน์ฐานข้อมูล

date = models.DateTimeField(null=True)

blank=Trueกำหนดว่าฟิลด์จะต้องอยู่ในแบบฟอร์มหรือไม่ ซึ่งรวมถึงผู้ดูแลระบบและแบบฟอร์มที่คุณกำหนดเอง

title = models.CharField(blank=True) // title can be kept blank. ในฐานข้อมูล("")จะถูกจัดเก็บ null=True blank=Trueซึ่งหมายความว่าฟิลด์นี้เป็นทางเลือกในทุกสถานการณ์

epic = models.ForeignKey(null=True, blank=True)
// The exception is CharFields() and TextFields(), which in Django are never saved as NULL. Blank values a

เมื่อเราบันทึกสิ่งใดในผู้ดูแลระบบ Django การตรวจสอบความถูกต้องสองขั้นตอนจะเกิดขึ้นที่ระดับ Django และในระดับฐานข้อมูล เราไม่สามารถบันทึกข้อความในช่องตัวเลขได้

ฐานข้อมูลมีประเภทข้อมูลเป็น NULL ไม่มีอะไรเลย เมื่อ Django สร้างคอลัมน์ในฐานข้อมูล แสดงว่าคอลัมน์นั้นไม่สามารถเว้นว่างได้ และถ้าคุณจะพยายามบันทึก NULL คุณจะได้รับข้อผิดพลาดของฐานข้อมูล

นอกจากนี้ ในระดับ Django-Admin ฟิลด์ทั้งหมดจำเป็นโดยค่าเริ่มต้น คุณไม่สามารถบันทึกฟิลด์ว่าง Django จะส่งข้อผิดพลาดให้คุณ

ดังนั้น หากคุณต้องการบันทึกช่องว่าง คุณต้องอนุญาตในระดับ Django และฐานข้อมูล blank=True - จะอนุญาตช่องว่างในแผงผู้ดูแลระบบ null=True - จะอนุญาตให้บันทึก NULL ลงในคอลัมน์ฐานข้อมูล

null ใช้สำหรับฐานข้อมูลและช่องว่างสำหรับการตรวจสอบความถูกต้องของฟิลด์ที่คุณต้องการแสดงบนอินเทอร์เฟซผู้ใช้เช่น textfield เพื่อรับนามสกุลของบุคคล หากlastname=models.charfield (blank=true)ไม่ได้ขอให้ผู้ใช้ป้อนนามสกุล เนื่องจากตอนนี้เป็นฟิลด์ตัวเลือก หากlastname=models.charfield (null=true) หมายความว่าหากฟิลด์นี้ไม่ได้รับค่าใด ๆ จากผู้ใช้ ระบบจะเก็บค่าในฐานข้อมูลเป็นสตริงว่าง " "

Null เกี่ยวข้องกับฐานข้อมูลล้วนๆ ในขณะที่ว่างเปล่าเกี่ยวข้องกับการตรวจสอบ หากฟิลด์มี blank=True การตรวจสอบความถูกต้องบนไซต์ผู้ดูแลระบบของ Django จะอนุญาตให้ป้อนค่าว่าง หากฟิลด์มี blank=False ฟิลด์จะต้องใช้

Blank=False # this field is required.
Null=False # this field should not be null

Blank=True # this field is optional.
Null=True # Django uses empty string (''), not NULL.

หมายเหตุ: หลีกเลี่ยงการใช้null=Trueในช่องสตริงที่ใช้เช่นCharFieldและTextFieldและ/FileFieldImageField

อ้างอิง: Django null , Django blank

ในคำง่ายมาก ,

ว่างแตกต่างจากโมฆะ

nullเป็นอย่างหมดจดเกี่ยวข้องกับฐานข้อมูลในขณะที่ว่างเปล่ามีการตรวจสอบที่เกี่ยวข้อง (จำเป็นต้องใช้ในรูปแบบ)

ถ้าnull=Trueจังโก้จะstore empty values as NULL in the database. ถ้าเขตข้อมูลมีการตรวจสอบรูปแบบจะblank=True allow entry of an empty valueถ้าฟิลด์มีช่องว่าง=เท็จ ฟิลด์นั้นจะต้อง

คำตอบง่ายๆ คือ Null สำหรับตารางฐานข้อมูลในขณะที่ Blank สำหรับแบบฟอร์ม Django

null - ค่าดีฟอลต์คือ False ถ้า True Django จะเก็บค่าว่างเป็น null ในฐานข้อมูล

ว่างเปล่า - ค่าเริ่มต้นเป็นเท็จหากเป็นจริงฟิลด์นั้นได้รับอนุญาตให้ว่างเปล่า

เพิ่มเติม ไปที่ https://docs.djangoproject.com/en/3.0/topics/db/models/

ตารางด้านล่างนี้แสดงให้เห็นถึงความแตกต่างที่สำคัญ:

+--------------------------------------------------------------------+
| Purpose                  | null=True        | blank = True         |
|--------------------------|------------------|----------------------|
| Field can be empty in DB | Do this          | Unaffected           |
|--------------------------|------------------|----------------------|
| ModelForm(required field)| Unaffected       | field not required   |
|--------------------------|------------------|----------------------|
| Form Validation          | Unaffected       | field not required   |
|--------------------------|------------------|----------------------|
| on_delete=SET_NULL       | Need this        | Unaffected           |
+--------------------------------------------------------------------+

ความหมายของ null=True และ blank=True ในโมเดลยังขึ้นอยู่กับวิธีกำหนดฟิลด์เหล่านี้ในคลาสของฟอร์ม

สมมติว่าคุณได้กำหนดคลาสต่อไปนี้:

class Client (models.Model):
    name = models.CharField (max_length=100, blank=True)
    address = models.CharField (max_length=100, blank=False)

หากคลาสแบบฟอร์มถูกกำหนดดังนี้:

class ClientForm (ModelForm):
    class Meta:
        model = Client
        fields = ['name', 'address']
        widgets = {
            'name': forms.TextInput (attrs = {'class': 'form-control form-control-sm'}),
            'address': forms.TextInput (attrs = {'class': 'form-control form-control-sm'})
        }

จากนั้น ฟิลด์ 'ชื่อ' จะไม่ถูกบังคับ (เนื่องจาก blank=True ในโมเดล) และฟิลด์ 'address' จะเป็นฟิลด์บังคับ (เนื่องจากช่องว่าง=False ในโมเดล)

อย่างไรก็ตาม หากคลาส ClientForm ถูกกำหนดดังนี้:

class ClientForm (ModelForm):
    class Meta:
        model = Client
        fields = ['name', 'address']

    name = forms.CharField (
        widget = forms.TextInput (attrs = {'class': 'form-control form-control-sm'}),
    )
    address = forms.CharField (
        widget = forms.TextInput (attrs = {'class': 'form-control form-control-sm'}),
    )

จากนั้น ทั้งสองฟิลด์ ('ชื่อ' และ 'ที่อยู่') จะเป็นฟิลด์บังคับ"เนื่องจากฟิลด์ที่กำหนดไว้อย่างเปิดเผยจะถูกปล่อยให้เป็นไปตามที่เป็นอยู่" ( https://docs.djangoproject.com/en/3.0/topics/forms/modelforms/ ) กล่าวคือ ค่าเริ่มต้นสำหรับแอตทริบิวต์ 'จำเป็น' ของฟิลด์แบบฟอร์มคือ True และจะกำหนดให้ฟิลด์ 'ชื่อ' และ 'ที่อยู่' ถูกกรอก แม้ว่าในแบบจำลอง ฟิลด์จะถูกตั้งค่าเป็น blank=True

เมื่อคุณตั้งค่าnull=trueมันจะตั้งค่าnullในฐานข้อมูลของคุณ หากไม่กรอกข้อมูลในฟิลด์ หากคุณตั้งค่าblank=trueจะไม่ตั้งค่าใด ๆ ให้กับฟิลด์

blank=Trueสามารถตั้งค่าฟิลด์โมเดลใดก็ได้เพื่อควบคุมว่าฟิลด์นั้นสามารถเว้นว่างไว้ได้หรือไม่เมื่อป้อนค่าในแบบฟอร์ม ที่นี่เรากำลังพูดถึงการป้อนข้อมูล

null=Trueหากเราตั้งค่าblank=Trueฟิลด์ฟิลด์โมเดลนั้นจะไม่ได้รับค่าใด ๆ ดังนั้นฐานข้อมูลหรือ Django จะต้องดำเนินการบางอย่างกับฟิลด์นั้นเมื่อข้อมูลถูกเขียนลงในฐานข้อมูล สำหรับเนื้อหาข้อความประเภทใดก็ตาม สตริงว่างจะถูกเก็บไว้ในฐานข้อมูล ดังนั้นจึงมีค่าที่จัดเก็บไว้ในฐานข้อมูล สำหรับฟิลด์ประเภทอื่นๆ เช่น ฟิลด์วันที่หรือตัวเลข เราใช้ประเภทข้อมูลพิเศษ "null" สามารถใช้ "null" ได้หากฟิลด์ที่อาจไม่มีค่า แต่โดยค่าเริ่มต้น Django จะไม่อนุญาตค่า "null" null=Trueนั่นคือเหตุผลที่คุณจะต้องกำหนดอย่างชัดเจน

สมมติว่าคุณ set blank=Trueสำหรับฟิลด์ที่ไม่ใช่ข้อความ แต่คุณไม่ได้ระบุ "null=True" Django จะไม่ทราบว่าจะจัดเก็บอะไรและจะทำให้เกิดข้อผิดพลาด

null = True || blank = True || null = True && blank = True

class TestModel(models.Model):
    field1 = models.CharField(max_length=100, null=True)
    field2 = models.CharField(max_length=100, blank=True)   # it's not a correct way
    field3 = models.CharField(max_length=100, null=True, blank=True)

ฐานข้อมูลสำหรับ: MySQL

CREATE TABLE TestModel (
     `id`        INT(10)        NOT     NULL      AUTO_INCREMENT,

     `field1`    VARCHAR(100)   NULL    DEFAULT   NULL,
     `field2`    VARCHAR(100)   NOT     NULL,
     `field3`    VARCHAR(100)   NULL    DEFAULT   NULL,
)

กรณี-01: null = True

db:   db   field is accepts null value
form: form field is `required`

NB: DB IS ACCEPTS NULL VALUE, BUT FORM FIELD IS REQUIRED. SO FORM IS 
SUBMITTED WHEN THIS FIELD HAVE SOME VALUE. it's good.

กรณี-02: blank = True

db:   db   field is not accepts null value
form: form field is `optional`

NB: FORM IS VALID WITHOUT ANY VALUE, BUT DB IS NOT ACCEPTS NULL VALUE.
SO THE FORM IS SUBMITTED WITHOUT ANY VALUE THEN BOOM. it's worst.

กรณี-03: null = True && blank = True

db:   db   field is accepts null value
form: form field is `optional`

NB: HERE FORM FIELD IS OPTIONAL & FORM IS VALID WITHOUT ANY VALUE 
& DB ALSO ACCEPTS NULL VALUE. SO, IT'S BEST TO USE `null=True && blank=True`

:)