Shulou(Shulou.com)06/03 Report--

This article mainly introduces "what is the connection between Django and foreign keys?" In daily operation, I believe many people have doubts about what is the connection between Django and foreign keys. Xiaobian consulted all kinds of information and sorted out simple and easy to use operation methods. I hope to help you answer the doubts about "what is the connection between Django and foreign keys?" Next, please follow the small series to learn together!

Note: This article requires you to have a certain database knowledge. The database syntax in this article is written in mysql.

In Django, there are three kinds of relationships related to foreign keys. Let's introduce them one by one.

OneToManyField

This is best understood. To put it bluntly, it is the most common foreign key. Look at the following two models:

class GoodsType(models.Model): name = models.CharField(max_length=50)class GoodsMessage(models.Model): Title = models.CharField(max_length='100')#Item Title Category = models.ManyToManyField(GoodsType) #Item Label

Analyze:

Here Django creates two tables in the database:

create table GoodsType( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(50) NOT NULL, PRIMARY KEY (`id`))create table GoodsMessage( `id` int(11) NOT NULL AUTO_INCREMENT, `Title` varchar(50) NOT NULL, `Category_id` int(11) NOT NULL, PRIMARY KEY (`id`), FOREIGN KEY (`Category_id`) REFERENCES `SchoolBuy_goodstype` (`id`))

The result is that a commodity corresponds to a category, i.e. the category is a foreign key to the commodity.

OneToOneField

This relationship is similar to OneToMany, which is a foreign key with constraints. Consider the following two models:

class GoodsType(models.Model): name = models.CharField(max_length=50)class GoodsMessage(models.Model): Title = models.CharField(max_length='100')#Item Title Category = models.OneToManyField(GoodsType) #Item Label (becomes one-to-one relationship)

What tables will they make the database create?

create table GoodsType ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(50) NOT NULL, PRIMARY KEY (`id`))create table GoodsMessage ( `id` int(11) NOT NULL AUTO_INCREMENT, `Title` varchar(50) NOT NULL, `Category_id` int(11) NOT NULL, PRIMARY KEY (`id`), FOREIGN KEY (`Category_id`) REFERENCES `SchoolBuy_goodstype` (`id`), UNIQUE KEY `SchoolBuy_goodsmessage_Category_id_4dd415fc1e19cf24_uniq` (`Category_id`) #added)

So it is obvious here that in these two models, each commodity has a commodity type, and each commodity type belongs to only one commodity (with UNIQUE constraint), that is, if the type of my commodity A is computer, then the types of other commodities cannot be defined as computers.

Therefore, the correspondence between goods and types must not be OneToOne, but OneToMany.

Where is OneToOne used? Here is a place to say that when extending Django's User model, because the system does not have enough fields, one of the most basic extension methods is to define a User_profile table as an extension of the user, so a user record will only have one extension table record, and this record only belongs to the user.

ManyToMany

Many-to-many relationships, here we assume a scenario:

I now have a list of items that have some pictures (variable number), so I can use many-to-many relationships:

class GoodsPicture(models.Model): Pic = models.ImageField(upload_to='pic/')class GoodsMessage(models.Model): Title = models.CharField(max_length='100') #Commodity Title Pic = models.ManyToManyField(GoodsPicture)

The database is different here, and three tables have been established, as follows:

create table GoodsPicture ( `id` int(11) NOT NULL AUTO_INCREMENT, `Pic` varchar(255) NOT NULL, # Django Binary image file is used to store images on hard disk, database only stores image path PRIMARY KEY (`id`))create table GoodsMessage ( `id` int(11) NOT NULL AUTO_INCREMENT, `Title` varchar(50) NOT NULL, PRIMARY KEY (`id`) #Note that there are no foreign key constraints here) create table GoodsMessage_CoodsPicture ( `id` int(11) NOT NULL AUTO_INCREMENT, `goodsmessage_id` int(11) NOT NULL, `goodpicture_id` int(11) NOT NULL, PRIMARY KEY (`id`), UNIQUE KEY `goodsmessage_id`(`goodsmessage_id`,`goodspicture_id`), FOREIGN KEY (`goodsmessage_id`) REFERENCES `GoodsMessage` (`id`), FOREIGN KEY (`goodstype_id`) REFERENCES `GoodsPicture` (`id`))

I won't talk about the first two tables, but mainly talk about the third table GoodsMessage_CoosPicture.

Django uses this table to record a piece of data: a product corresponds to a picture. There is a UNIQUE constraint that states that there cannot be duplicate records.

In this way, every time you query the GoodsMessage_CoodsPicture table, you can get the picture corresponding to a certain item.

At this point, the study of "Django and foreign keys have anything to do with it" is over, hoping to solve everyone's doubts. Theory and practice can better match to help everyone learn, go and try it! If you want to continue learning more relevant knowledge, please continue to pay attention to the website, Xiaobian will continue to strive to bring more practical articles for everyone!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.