一 表关系回顾

在讲解MySQL时,我们提到,把应用程序的所有数据都放在一张表里是极不合理的。

比如我们开发一个员工管理系统,在数据库里只创建一张员工信息表,该表有四个字段:工号、姓名、部门名、部门职能描述,此时若公司有1万名员工,但只有3个部门,因为每一名员工后都需要跟着部门信息(部门名、部门职能),所以将会导致部门信息出现大量重复、浪费空间。

解决方法就是将数据存放于不同的表中,然后基于foreign key建立表之间的关联关系。

左表 <-------------------------------> 右表

# 步骤一:先分析
#分析1、先站在左表的角度
是否左表的多条记录可以对应右表的一条记录 #分析2、再站在右表的角度去找
是否右表的多条记录可以对应左表的一条记录 # 步骤二:后确定关系
# 多对一
如果只有"分析1"成立,那么可以确定两张表的关系是:左表多对一右表,关联字段应该创建在左表中,然后foreign key 右表一个字段(通常是id)
如果只有"分析2"成立,那么可以确定两张表的关系是:右表多对一左表,关联字段应该创建在右表中,然后foreign key 左表一个字段(通常是id) # 一对一
如果"分析1"和"分析2"都不成立,而是左表的一条记录唯一对应右表的一条记录,反之亦然。这种情况很简单,就是在左表foreign key右表的基础上,将左表的关联字段设置成unique即可 # 多对多
如果"分析1"和"分析2"同时成立,则证明这两张表是一个双向的多对一,即多对多,需要创建一张单独的新表来专门存放二者的关系,关联字段应该创建在新表中,然后在新表中分别foreign key两张表的id字段

我们以一个图书管理系统为背景,设计了下述四张表,让我们来找一找它们之间的关系

书籍表:app01_book

出版社表:app01_publish

作者表:app01_author

作者详细信息表:app01_authordetail

例1、app01_book与app01_publish

找关系

左表(app01_book)<------------------------------->右表(app01_publish)

# 步骤一:
#分析1、先站在左表的角度
左表的多条记录代表多版本书籍,右表的一条记录代表一个出版社,多本书籍对应同一个出版社 ️ #分析2、再站在右表的角度去找
右表的多条记录代表多个出版社,左表的一条记录代表一本书,多个出版社不能出版同一本书 ✘ # 步骤二:后确定关系
# 多对一
只有"分析1"成立,那么可以确定两张表的关系是:左表(app01_book)多对一右表(app01_publish),关联字段应该创建在左表(app01_book)中,然后foreign key 右表(app01_publish)的id字段

sql语句

# 1、由于foreign key的影响,必须先创建被关联表
CREATE TABLE app01_publish (
id INT PRIMARY KEY auto_increment,
name VARCHAR (20)
); # 2、才能创建出关联表
CREATE TABLE app01_book (
id INT PRIMARY KEY auto_increment,
title VARCHAR (20),
price DECIMAL (8, 2),
pub_date DATE,
publish_id INT, # 新增关联字段
FOREIGN KEY (publish_id) REFERENCES app01_publish (id)
ON UPDATE CASCADE ON DELETE CASCADE
);

例2、app01_author与app01_authordetail

找关系

左表(app01_author)<------------------------------->右表(app01_authordetail)

一个作者唯一对应一条自己的详情信息,反之亦然,所以两张表是一对一的关系。在左表中新增关联字段并添加unique约束,然后foreign key右表

sql语句

# 1、由于foreign key的影响,必须先创建被关联表
CREATE TABLE app01_authordetail (
id INT PRIMARY KEY auto_increment,
tel VARCHAR (20)
); # 2、才能创建出关联表
CREATE TABLE app01_author (
id INT PRIMARY KEY auto_increment,
name VARCHAR (20),
age INT,
authordetail_id INT UNIQUE, # 新增关联字段,并添加唯一性约束unique
FOREIGN KEY (authordetail_id) REFERENCES app01_authordetail (id)
ON UPDATE CASCADE ON DELETE CASCADE
);

例3、app01_book与app01_author

找关系

左表(app01_book)<------------------------------->右表(app01_author)

# 步骤一:
#分析1、先站在左表的角度
左表的多条记录代表多版本书籍,右表的一条记录代表一个作者,多本书籍可以由同一个作者编写 ️ #分析2、再站在右表的角度去找
右表的多条记录代表多个作者,左表的一条记录代表一本书,多个作者可以合作编写同一本书 ️ # 步骤二:后确定关系
# 多对多
"分析1"和"分析2"同时成立,证明这两张表是多对多的关系,需要创建一张单独的新表来专门存放二者的关系,关联字段应该创建在新表中,然后在新表中分别foreign key两张表的id字段

sql语句

# 1、创建被关联表一:app01_book,例1中已创建
# 2、创建被关联表二:app01_author,例2中已创建 # 3、创建新表,存放app01_book于app01_author的关联关系
CREATE TABLE app01_book_authors (
id INT PRIMARY KEY auto_increment,
book_id INT, # 新增关联字段,用来关联表app01_book
author_id INT, # 新增关联字段,用来关联表app01_author
FOREIGN KEY (book_id) REFERENCES app01_book (id) ON UPDATE CASCADE ON DELETE CASCADE,
FOREIGN KEY (author_id) REFERENCES app01_author (id) ON UPDATE CASCADE ON DELETE CASCADE
);

上述三个例子中生成的表如下

二 创建模型

模型类如下

from django.db import models

# 表app01_publish
class Publish(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=20) # 表app01_book
class Book(models.Model):
nid = models.AutoField(primary_key=True)
title = models.CharField(max_length=20)
price = models.DecimalField(max_digits=8, decimal_places=2)
pub_date = models.DateField() # 表app01_book多对一表app01_publish,参数to指定模型名,参数to_field指定要关联的那个字段
publish = models.ForeignKey(to='Publish',to_field='nid',on_delete=models.CASCADE) # 我们自己写sql时,针对书籍表与作者表的多对关系,需要自己创建新表,而基于django的orm,下面这一行代码可以帮我们自动创建那张关系表
authors=models.ManyToManyField(to='Author')
# 变量名为authors,则新表名为app01_book_authors,若变量名为xxx,则新表名为app01_book_xxx # 表app01_author
class Author(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=20)
age = models.IntegerField() # 表app01_author一对一表app01_authordetail
author_detail = models.OneToOneField(to='AuthorDetail',to_field='nid',unique=True,on_delete=models.CASCADE) # 表app01_authordetail
class AuthorDetail(models.Model):
nid = models.AutoField(primary_key=True)
tel = models.CharField(max_length=20)

强调:

在创建关联时,针对参数to,如果传入的是字符串(to="模型名"),则模型类的定义不区分先后顺序,如果传入的是模型名(to=Author),则Author类必须事先定义

三 添加、删除、修改记录

3.1 添加记录

强调:上图所示的表名、字段名都是mysql中的真实表/物理表,而我们下述所示所有操作,都是通过模型类来操作物理表,例如无论增删改查,所使用的字段名都模型类中的字段

按照上图所示,由于foreign key的关系,我们需要事先往app01_publish与app01_authordetail里插入记录

# 1、需求:通过模型Publish往表app01_publish里插入三家出版社
Publish.objects.create(name='北京出版社')
Publish.objects.create(name='长春出版社')
Publish.objects.create(name='大连出版社') # 2、需求:通过模型AuthorDetail往表app01_authordetail里插入三条作者详情
AuthorDetail.objects.create(tel='18611312331')
AuthorDetail.objects.create(tel='15033413881')
AuthorDetail.objects.create(tel='13011453220')

按照上图所示,插入时会涉及到多张表,我们同样分三种情况来介绍

1、多对一:app01_book与app01_publish

# 需求:书籍(葵花宝典、菊花宝典、桃花宝典)都是在北京出版社出版的
# 1、先通过模型Publish从出版社表app01_publish查出北京出版社
publish_obj=Publish.objects.filter(name='北京出版社').first()
# 上述代码也可以简写为:publish_obj=Publish.objects.get(name='北京出版社') # 2、再通过模型Book往书籍表app01_book里插入三本书籍与出版社的对应关系
# 方式一:使用publish参数指定关联
book_obj1=Book.objects.create(title='葵花宝典',price=2000,pub_date='1985-3-11',publish=publish_obj) book_obj2=Book.objects.create(title='菊花宝典',price=3000,pub_date='1990-1-21',publish=publish_obj) book_obj3=Book.objects.create(title='桃花宝典',price=4000,pub_date='1991-1-23',publish=publish_obj) # 方式二:使用publish_id参数指定关联
book_obj1=Book.objects.create(title='葵花宝典',price=2000,pub_date='1985-3-11',publish_id=publish_obj.nid) book_obj2=Book.objects.create(title='菊花宝典',price=3000,pub_date='1990-1-21',publish_id=1) # 在已经出版社id的情况下,可以直接指定 book_obj3=Book.objects.create(title='桃花宝典',price=4000,pub_date='1991-1-23',publish_id=1) # 注意:无论方式一还是方式二得到的书籍对象book_obj1、book_obj2、book_obj3
# 都可以调用publish字段来访问关联的那一个出版社对象
# 都可以调用publish_id来访问关联的那一个出版社对象的nid
print(book_obj1.publish,book_obj1.publish_id)
print(book_obj2.publish,book_obj2.publish_id)
print(book_obj3.publish,book_obj3.publish_id)
# 三本书关联的是同一个出版社,所以输出结果均相同

参照上述步骤,把剩余三本书与出版社的对应关系也插入

book_obj1 = Book.objects.create(title='玉女心经', price=5000, pub_date='1988-3-24', publish_id=2)

book_obj2 = Book.objects.create(title='玉男心经', price=3000, pub_date='1985-6-17', publish_id=2)

book_obj3 = Book.objects.create(title='九阴真经', price=6000, pub_date='1983-8-17', publish_id=3)

2、一对一:app01_author与app01_authordetail

# 需求:插入三个作者,并与作者详情表一一对应
# 由于作者详情表我们已经事先创建好记录,所以只需要往作者表插入记录即可
# 方式一:需要事先过滤出作者详情的对象,然后通过模型Author的字段author来指定要关联的作者详情对象(略) # 方式二:确定作者详情对象的id,然后通过模型Author通过字段author_id来指定关联关系,
Author.objects.create(name='egon',age=18,author_detail_id=1)
Author.objects.create(name='kevin',age=38,author_detail_id=2)
Author.objects.create(name='rose',age=28,author_detail_id=3)

3、多对多:app01_book与app01_author

# 我们参照物理表app01_book_authors制定需求,需要创建如下关系
# 1、葵花宝典的作者为:egon、kevin
# 2、菊花宝典的作者为:egon、kevin、rose
# 3、桃花宝典的作者为:egon、kevin
# 4、玉女心经的作者为:kevin、rose
# 5、玉男心经的作者为:kevin
# 6、九阴真经的作者为:egon、rose # 需要创建出上述关系,具体做法如下
# 1、先获取书籍对象
book_obj1=Book.objects.get(title='葵花宝典')
book_obj2=Book.objects.get(title='菊花宝典')
book_obj3=Book.objects.get(title='桃花宝典')
book_obj4=Book.objects.get(title='玉女心经')
book_obj5=Book.objects.get(title='玉男心经')
book_obj6=Book.objects.get(title='九阴真经') # 2、然后获取作者对象
egon=Author.objects.get(name='egon')
kevin=Author.objects.get(name='kevin')
rose=Author.objects.get(name='rose') # 3、最后依次创建上述关系:在原生SQL中多对多关系涉及到操作第三张关系表,但是在ORM中我们只需要操作模型类Book下的字段author即可
book_obj1.authors.add(egon,kevin)
book_obj2.authors.add(egon,kevin,rose)
book_obj3.authors.add(egon,kevin)
book_obj4.authors.add(kevin,rose)
book_obj5.authors.add(kevin)
book_obj6.authors.add(egon,rose)

可以通过书籍对象下的authors字段获取其所关联的所有作者对象

book_obj1.authors.all() # 返回一个存有多个作者的queryset

3.2 删除、修改记录

# 1、book_obj.authors.remove() :将某个特定的对象从被关联对象集合中去除
# 从菊花宝典的作者集合中去掉作者rose
rose = Author.objects.get(name='rose')
book_obj2 = Book.objects.get(title='菊花宝典')
book_obj2.authors.remove(rose) # 2、book_obj.authors.clear():清空被关联对象集合
# 清空菊花宝典所关联的所有作者
book_obj2 = Book.objects.get(title='菊花宝典')
book_obj2.authors.clear() # 3、book_obj.authors.set():先清空再重新设置 
# 玉男心经的作者原来为kevin,要求设置为egon、rose
egon=Author.objects.get(name='egon')
rose=Author.objects.get(name='rose') book_obj5 = Book.objects.get(title='玉男心经') book_obj5.authors.set([egon,rose]) # 多个作者对象放到列表里

四 查询记录

数据库操作最常用的还是查询操作,在介绍ORM下多表关联查询时,需要事先记住关于ORM模型的一个非常重要的概念:在使用模型类进行多表关联查询时,如果确定两张表存在关联关系,那么在选取一个表作为起始(为了后续描述方便,我们将其简称为"基表")后,可以跨表引用来自另外一张中的字段值,这存在正向与反向之分

如果关联字段存在于基表中,称之为正向查询,否则,称之为反向查询

例如表模Book与Publish,关联字段存在于Book中

# 当以Book为基表时,称之为正向查询
Book(基表)-------正向---------->Publish # 当以Publish为基表时,称之为反向查询
Book<-------反向----------Publish(基表)

使用原生sql进行多表关联查询时无非两种方式:子查询、join连表查询,ORM里同样有两种查询方式(严格依赖正向、反向的概念)

4.1 基于对象的跨表查询

1、跨两张表查询

1.1、一对一查询(模型类Author与AuthorDetail)

正向查询,按关联字段:author_detail

# 需求:查询作者egon的手机号
# 1、先取出作者对象
egon=Author.objects.filter(name='egon').first()
# 2、正向查询:根据作者对象下的关联字段author_detail取到作者详情
print(egon.author_detail.tel) # 输出:18611312331

反向查询,按模型名(小写):author

# 需求:查询手机号为'18611312331'的作者名
# 1、先取出作者的详情对象
tel=AuthorDetail.objects.filter(tel='18611312331').first()
# 2、反向查询:根据小写的模型名author取到作者对象
print(tel.author.name) # 输出:egon

1.2、多对一查询(模型类Book与Publish)

正向查询,按关联字段:publish

# 需求:查询葵花宝典的出版社名字
# 1、先取书籍对象
book_obj=Book.objects.filter(title='葵花宝典').first()
# 2、正向查询:根据书籍对象下的关联字段publish取到出版社
print(book_obj.publish.name) # 输出:北京出版社

反向查询,按模型名(小写)_set:book_set

# 需求:查询北京出版社都出版的所有书籍名字
# 1、先取出出版社对象
publish_obj=Publish.objects.filter(name='北京出版社').first()
# 2、反向查询:根据book_set取到所有的书籍
book_objs=publish_obj.book_set.all()
print([book_obj.title for book_obj in book_objs]) # 输出:['葵花宝典', '菊花宝典', '桃花宝典']

1.3、多对多查询(模型类Book与Author)

正向查询,按关联字段,如authors

# 需求:查询葵花宝典的所有作者
# 1、先取出书籍对象
book_obj=Book.objects.filter(title='葵花宝典').first()
# 2、正向查询:根据书籍对象下的关联字段authors取到所有作者
author_objs=book_obj.authors.all()
print([obj.name for obj in author_objs]) # 输出:['egon', 'kevin']

反向查询,按模型名(小写)_set:如author_set

# 需求:查询作者rose出版的所有书籍
# 1、先取出作者对象
egon=Author.objects.filter(name='rose').first()
# 2、反向查询:根据book_set取到作者对象
book_objs=egon.book_set.all()
print([book_obj.title for book_obj in book_objs]) # 输出:['玉女心经', '九阴真经', '玉男心经']

2、连续跨 > 2张表查询

连续跨 > 2张表的操作的套路与上面的案例都是一样的

# 需求:查询葵花宝典的作者们的手机号

book_obj=Book.objects.filter(title='葵花宝典').first()
author_objs=book_obj.authors.all()
print([author_obj.author_detail.tel for author_obj in author_objs])
# 输出:['18611312331', '15033413881']

4.2 基于双下划线的跨表查询

1、跨两张表查询

1.1、一对一查询(模型类Author与AuthorDetail)

正向查询,按关联字段+双下划线:author_detail__

# 需求:查询作者egon的手机号
# 注意values()中的参数是:关联字段名__要取的那张被关联表中的字段
res = Author.objects.filter(name='egon').values('author_detail__tel').first()
print(res['author_detail__tel']) # {'author_detail__tel': '18611312331'} # 注意:基于双下划线的跨表查询会被django的orm识别为join操作,所以上述代码相当于如下sql,后续案例均是相同原理,我们不再累述
select app01_authordetail.tel from app01_author inner join app01_authordetail on app01_author.author_detail_id = app01_authordetail.nid where app01_author.name = 'egon';

反向查询,按模型名(小写)+双下划线:author__

# 需求:查询手机号为'18611312331'的作者名
# 注意values()中的参数是:小写的模型名__要取的那张被关联表中的字段
res=AuthorDetail.objects.filter(tel='18611312331').values('author__name').first()
print(res) # {'author__name': 'egon'}

补充:基表决定了正向还是反向

# 1、针对上例中正向查询的需求:查询作者egon的手机号,如果我们选取的基表是AuthorDetail,那么就成了反向查询,应该用反向查询的语法
res = AuthorDetail.objects.filter(author__name='egon').values('tel').first()
print(res) # {'tel': '18611312331'} # 2、针对上例中反向查询的需求:查询手机号为'18611312331'的作者名,如果我们选取的基表是Author,那么就成了正向查询,应该用正向查询的语法
res=Author.objects.filter(author_detail__tel='18611312331').values('name').first()
print(res) # {'name': 'egon'}

1.2、多对一查询(模型类Book与Publish)

正向查询,按关联字段+双下划线:publish__

# 需求:查询葵花宝典的出版社名字
# 注意values()中的参数是:关联字段名__要取的那张被关联表中的字段
res=Book.objects.filter(title='葵花宝典').values('publish__name').first()
print(res['publish__name']) # {'publish__name': '北京出版社'}

反向查询,按模型名(小写)+双下划线:book__

# 需求:查询北京出版社都出版的所有书籍名字
# 注意values()中的参数是:小写的模型名__要取的那张被关联表中的字段
res = Publish.objects.filter(name='北京出版社').values('book__title')
print(res) # <QuerySet [{'book__title': '葵花宝典'}, {'book__title': '菊花宝典'}, {'book__title': '桃花宝典'}]>

补充:基表决定了正向还是反向

# 1、针对上例中正向查询的需求:查询葵花宝典的出版社名字,如果我们选取的基表是Publish,那么就成了反向查询,应该用反向查询的语法
res = Publish.objects.filter(book__title='葵花宝典').values('name').first()
print(res) # {'name': '北京出版社'} # 2、针对上例中反向查询的需求:查询北京出版社都出版的所有书籍名字,如果我们选取的基表是Book,那么就成了正向查询,应该用正向查询的语法
res=Book.objects.filter(publish__name='北京出版社').values('title')
print(res) # <QuerySet [{'title': '葵花宝典'}, {'title': '菊花宝典'}, {'title': '桃花宝典'}]>

1.3、多对多查询(模型类Book与Author)

正向查询,按关联字段+双下划线:authors__

# 需求:查询葵花宝典的所有作者
# 注意values()中的参数是:关联字段名__要取的那张被关联表中的字段
res=Book.objects.filter(title='葵花宝典').values('authors__name')
print(res) # <QuerySet [{'authors__name': 'egon'}, {'authors__name': 'kevin'}]>

反向查询,按模型名(小写)+双下划线:如book__

# 需求:查询作者rose出版的所有书籍
# 注意values()中的参数是:小写的模型名__要取的那张被关联表中的字段
res = Author.objects.filter(name='rose').values('book__title')
print(res) # <QuerySet [{'book__title': '玉女心经'}, {'book__title': '九阴真经'}, {'book__title': '玉男心经'}]>

补充:基表决定了正向还是反向

# 1、针对上例中正向查询的需求:查询葵花宝典的所有作者,如果我们选取的基表是authors,那么就成了反向查询,应该用反向查询的语法
res=Author.objects.filter(book__title='葵花宝典').values('name')
print(res) # <QuerySet [{'name': 'egon'}, {'name': 'kevin'}]> # 2、针对上例中反向查询的需求:查询作者rose出版的所有书籍,如果我们选取的基表是Book,那么就成了正向查询,应该用正向查询的语法
res=Book.objects.filter(authors__name='rose').values('title')
print(res) # <QuerySet [{'title': '玉女心经'}, {'title': '九阴真经'}, {'title': '玉男心经'}]>

2、连续跨 > 2张表查询

连续跨 > 2张表的操作的套路与上面的案例都是一样的,可以连续接n个双下划线,只需要在每次连双下划线时,确定是正向还是反向即可

# 需求1:查询北京出版社出版过的所有书籍的名字以及作者的姓名、手机号
# 方式一:基表为Publish
res=Publish.objects.filter(name='北京出版社').values_list('book__title','book__authors__name','book__authors__author_detail__tel') # 方式二:基表为Book
res=Book.objects.filter(publish__name='北京出版社').values_list('title','authors__name','authors__author_detail__tel') # 循环打印结果均为
for obj in res:
print(obj)
'''
输出:
('葵花宝典', 'egon', '18611312331')
('菊花宝典', 'egon', '18611312331')
('桃花宝典', 'egon', '18611312331')
('葵花宝典', 'kevin', '15033413881')
('菊花宝典', 'kevin', '15033413881')
('桃花宝典', 'kevin', '15033413881')
('菊花宝典', 'rose', '13011453220')
''' # 需求2:查询手机号以186开头的作者出版过的所有书籍名称以及出版社名称
# 方式一:基表为AuthorDetail
res=AuthorDetail.objects.filter(tel__startswith='186').values_list('author__book__title','author__book__publish__name') # 方式二:基表为Book
res=Book.objects.filter(authors__author_detail__tel__startswith='186').values_list('title','publish__name') # 方式三:基表为Publish
res=Publish.objects.filter(book__authors__author_detail__tel__startswith='186').values_list('book__title','name') # 循环打印结果均为
for obj in res:
print(obj)
'''
输出:
('葵花宝典', '北京出版社')
('菊花宝典', '北京出版社')
('桃花宝典', '北京出版社')
('九阴真经', '大连出版社')
'''

7、Django之模型层第二篇:多表操作的更多相关文章

  1. Django之模型层第二篇:多表操作

    Django之模型层第二篇:多表操作 一 表关系回顾 ​ 在讲解MySQL时,我们提到,把应用程序的所有数据都放在一张表里是极不合理的. ​ 比如我们开发一个员工管理系统,在数据库里只创建一张员工信息 ...

  2. Django之模型层第一篇:单表操作

    Django之模型层第一篇:单表操作 一 ORM简介 ​ 我们在使用Django框架开发web应用的过程中,不可避免地会涉及到数据的管理操作(如增.删.改.查),而一旦谈到数据的管理操作,就需要用到数 ...

  3. 6、Django之模型层第一篇:单表操作

    一 ORM简介 我们在使用Django框架开发web应用的过程中,不可避免地会涉及到数据的管理操作(如增.删.改.查),而一旦谈到数据的管理操作,就需要用到数据库管理软件,例如mysql.oracle ...

  4. Django基础模型层(77-78)

    jango框架之模型层(d77-78)一 单表操作: 1 mysql数据库:settings里配置  'default': {   # key值必须都是大写   'ENGINE': 'django.d ...

  5. Django框架-模型层

    Django框架-模型层 一.单表查询之必知必会13条 1.时间字段中的两个关键性参数 create_time = models.DateField() # 年月日 create_time = mod ...

  6. 64、django之模型层(model)--建表、查询、删除基础

    要说一个项目最重要的部分是什么那铁定数据了,也就是数据库,这篇就开始带大家走进django关于模型层model的使用,model主要就是操纵数据库不使用sql语句的情况下完成数据库的增删改查.本篇仅带 ...

  7. 【Django】模型层说明

    [Django模型层] 之前大概介绍Django的文章居然写了两篇..这篇是重点关注了Django的模型层来进行学习. ■ 模型定义 众所周知,Django中的模型定义就是定义一个类,其基本结构是这样 ...

  8. django之模型层(model)--建表、查询、删除基础

    要说一个项目最重要的部分是什么那铁定数据了,也就是数据库,这篇就开始带大家走进django关于模型层model的使用,model主要就是操纵数据库不使用sql语句的情况下完成数据库的增删改查.本篇仅带 ...

  9. 67、django之模型层(model)--查询补充及mookie

    本篇导航: F查询与Q查询 cookie 一.F查询与Q查询 1.以Book表为例 class Book(models.Model) : title = models.CharField(max_le ...

随机推荐

  1. mysql时间SQL

    生成随机时间 -- 带时分秒 select FROM_UNIXTIME(UNIX_TIMESTAMP('20100101000000')+ROUND(RAND()*(UNIX_TIMESTAMP()- ...

  2. 日常使用 ADB 命令

    最近项目中经常与安卓设备相连,用到adb命令.整理一下常用命令. wifi控制命令 adb connect IP 若连接失败,可尝试插数据线运行以下两条命令后,方可拔掉数据线,在设备未关闭之前可以直接 ...

  3. 《穷查理年鉴》贪嗔痴 & 懒贪装(关于败坏)

    贪嗔痴 & 懒贪装 1)伤害 041.仇恨加重伤害,漠视消除伤害. 042.90%的伤害是自己造成的. 044.伤害你的敌人使你比他更低下;仇恨使你和他一样;宽恕才能让你超越他. 109.让仇 ...

  4. C# 软件版本号

    如果需要查看更多文章,请微信搜索公众号 csharp编程大全,需要进C#交流群群请加微信z438679770,备注进群, 我邀请你进群! ! ! --------------------------- ...

  5. C++单链表操作

    #include <stdio.h> typedef struct _Node{   int value;   _Node *next;}Node; void AddNodeTail(No ...

  6. 用-pthread替代-lpthread

    -pthread 在多数系统中,-pthread会被展开为"-D_REENTRANT -lpthread".作为编译参数可以通知系统函数开启多线程安全特性,比如将errno定义线程 ...

  7. Exists 和Not Exists使用

    描述:exists表示()内子查询语句返回结果不为空说明where条件成立就会执行主sql语句,如果为空就表示where条件不成立,sql语句就不会执行.not exists和exists相反,子查询 ...

  8. spring boot:在项目中引入第三方外部jar包集成为本地jar包(spring boot 2.3.2)

    一,为什么要集成外部jar包? 不是所有的第三方库都会上传到mvnrepository, 这时我们如果想集成它的第三方库,则需要直接在项目中集成它们的jar包, 在操作上还是很简单的, 这里用luos ...

  9. go 多协程爬取图片

    package main import ( "fmt" "github.com/antchfx/htmlquery" "golang.org/x/ne ...

  10. 第三章 rsync 命令详解和实战用法

    一.rsync传输模式 1.本地模式2.远程模式3.守护进程模式 二.守护进程模式 1.安装rsync[root@backup ~]# yum -y install rsync 2.配置rsync[r ...