沧州市网站建设电话/南京百度网站推广

一 ORM的简介

MVC或者MVC框架中包括的一个重要部分就是ORM，它实现了数据模型与数据库的解耦。
即数据模型的设计不需要依赖于特定的数据库，通过简单的配置可以轻松更换数据库，这可以大大减少开发人员的工作量

二 数据库的设置

若想要将模型转为mysql的表，需要在settings中配置：

DATABASES = {
            'default':{
                'ENGINE':'django.db.backends.mysql',
                'NAME':'bms'                # 要连接的数据库，连接前要创建好
                'USER':'root'                # 连接数据库的用户名
                'PASSWORD':'',                # 连接数据库的密码
                'HOST':"127.0.0.1",            # 连接主机的IP
                'PORT':3306                    # 数据库端口号
                }
           }

注意点1

    NAME即数据库的名字,在mysql连接前该数据库必须已经建立，而上面的sqlite数据库下的db.sqlite3则是项目自动创建USER和PASSWORD，分别是数据库的用户名和密码。设置完成，在启动Django项目前，需要先激活mysql。然后，项目启动会报错：no module named MySQLdb。
   这是因为django默认你导入的驱动是MySQLdb，可是MYSQLdb对于py3有很大问题，所以我们需要驱动PyMySQL,所以,我们只需要在项目名文件下的__init__.py里面写入：

impor pymysql
pymysql.install_as_MYSQLdb()
最后通过两条数据库迁移命令在指定的数据库表中创建表:
python manage.py makemigrations
python manage.py migrate

 

注意点2
    要确保配置文件中的INSTALLED_APPS中写入我们创建的app名称

注意点3
    如果想打印orm转换sql的过程，需要在settings进行如下配置

LOGGING = {'version':1,'disable_existing_loggers':False,'handlers':{'console':{'level':'DEBUG'                        'class':'loggin.StreamHandler',},},'loggers':{'django.db.backends':{'handlers':['console']'propagate':True,'level':'DEBUG',},}，}

 

三 表的创建以及单表操作 

1 创建一张表

首先要在app中的moudels.py中创建表
代码：

from django.db import modelsclass Book(models.Model):id = models.AutoFiled(primary_key=True)title = models.CharField(max_length=32)state = models.BooleanFiled()pub_date = models.DateField()price = models.DecimalFiled(max_digits=8,decimal_places=2)publish = models.CharField(max_legth=32)

 

modles方法创建表的主要字段：

  AutoField(Field)- int自增列，必须填入参数 primary_key=TrueBigAutoField(AutoField)- bigint自增列，必须填入参数 primary_key=True注：当model中如果没有自增列，则自动会创建一个列名为id的列from django.db import modelsclass UserInfo(models.Model):# 自动创建一个列名为id的且为自增的整数列username = models.CharField(max_length=32)class Group(models.Model):# 自定义自增列nid = models.AutoField(primary_key=True)name = models.CharField(max_length=32)SmallIntegerField(IntegerField):- 小整数 -32768 ～ 32767PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)- 正小整数 0 ～ 32767IntegerField(Field)- 整数列(有符号的) -2147483648 ～ 2147483647PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)- 正整数 0 ～ 2147483647BigIntegerField(IntegerField):- 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807BooleanField(Field)- 布尔值类型NullBooleanField(Field):- 可以为空的布尔值CharField(Field)- 字符类型- 必须提供max_length参数， max_length表示字符长度TextField(Field)- 文本类型EmailField(CharField)：- 字符串类型，Django Admin以及ModelForm中提供验证机制IPAddressField(Field)- 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制GenericIPAddressField(Field)- 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6- 参数：protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启刺功能，需要protocol="both"URLField(CharField)- 字符串类型，Django Admin以及ModelForm中提供验证 URLSlugField(CharField)- 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）CommaSeparatedIntegerField(CharField)- 字符串类型，格式必须为逗号分割的数字UUIDField(Field)- 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证FilePathField(Field)- 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能- 参数：path,                      文件夹路径match=None,                正则匹配recursive=False,           递归下面的文件夹allow_files=True,          允许文件allow_folders=False,       允许文件夹FileField(Field)- 字符串，路径保存在数据库，文件上传到指定目录- 参数：upload_to = ""      上传文件的保存路径storage = None      存储组件，默认django.core.files.storage.FileSystemStorageImageField(FileField)- 字符串，路径保存在数据库，文件上传到指定目录- 参数：upload_to = ""      上传文件的保存路径storage = None      存储组件，默认django.core.files.storage.FileSystemStoragewidth_field=None,   上传图片的高度保存的数据库字段名（字符串）height_field=None   上传图片的宽度保存的数据库字段名（字符串）DateTimeField(DateField)- 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]DateField(DateTimeCheckMixin, Field)- 日期格式      YYYY-MM-DDTimeField(DateTimeCheckMixin, Field)- 时间格式      HH:MM[:ss[.uuuuuu]]DurationField(Field)- 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型FloatField(Field)- 浮点型DecimalField(Field)- 10进制小数- 参数：max_digits，小数总长度decimal_places，小数位长度BinaryField(Field)- 二进制类型

modles方法字段参数

    null                数据库中字段是否可以为空db_column           数据库中字段的列名default             数据库中字段的默认值primary_key         数据库中字段是否为主键db_index            数据库中字段是否可以建立索引unique              数据库中字段是否可以建立唯一索引unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引unique_for_month    数据库中字段【月】部分是否可以建立唯一索引unique_for_year     数据库中字段【年】部分是否可以建立唯一索引verbose_name        Admin中显示的字段名称blank               Admin中是否允许用户输入为空editable            Admin中是否可以编辑help_text           Admin中该字段的提示信息choices             Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)error_messages      自定义错误信息（字典类型），从而定制想要显示的错误信息；字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date如：{'null': "不能为空.", 'invalid': '格式错误'}validators          自定义错误验证（列表类型），从而定制想要的验证规则from django.core.validators import RegexValidatorfrom django.core.validators import EmailValidator,URLValidator,DecimalValidator,\MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator如：test = models.CharField(max_length=32,error_messages={'c1': '优先错信息1','c2': '优先错信息2','c3': '优先错信息3',},validators=[RegexValidator(regex='root_\d+', message='错误了', code='c1'),RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),EmailValidator(message='又错误了', code='c3'), ])

元信息

class UserInfo(models.Model):nid = models.AutoField(primary_key=True)username = models.CharField(max_length=32)class Meta:# 数据库中生成的表名称 默认 app名称 + 下划线 + 类名db_table = "table_name"# 联合索引index_together = [("pub_date", "deadline"),]# 联合唯一索引unique_together = (("driver", "restaurant"),)# admin中显示的表名称
            verbose_name# verbose_name加sverbose_name_plural

2 添加表记录的方法

方式一

    # create方法的返回值book_obj就是插入表中的python红宝石这个本书记录对象
    book_Obj = Book.objects.create(title="python红宝石", state=True, price=100, publish="人民出版社", pub_date="2012-12-12")

方式二

    book_obj = Book(title="python红宝石", state=True, price=100, publish="人民出版社", pub_date="2012-12-12")
    book_Obj.save()

 

3 表查询的方法

查询API：

　　

<1> all()                        查询所有结果，返回一个queryset对象
<2> filter(**kwargs)             它包含了与所给予的筛选条件相匹配的对象
<3> get(**kwargs)                返回与筛选条件相匹配的对象，返回结果只有一个。如果筛选条件的对象超过一个或者没有会抛出异常
<4> exclude(**kwargs)            包含了与所筛选条件不匹配的对象
<5> order_by(*field)             对查询结果排序
<6> reverse()                    对查询结果反向排序
<7> count()                      返回数据库中匹配查询(QuerySet)的对象数量
<8> first()                      返回第一条记录
<9> last()                       返回最后一条记录
<10> exists()                    如果QuerySet包含数据就返回True,否则返回False
<11> values(*field)              返回一个ValueQuerySet,一个特殊的QuerSet,运行后得到的并不是一系列model实例化对象，而是一个可迭代的字典序序列
<12> values_list(*filed)         它与values()非常相似，它返回的是一个元祖序列,values返回的是一个字典序列。
<13> distinct()                  从返回结果中剔除重复记录

基于双下划线的模糊查询：

Book.object.filter(price__in=[100,200,300])
Book.object.filter(price__get=100)
Book.object.filter(price__lt=100)
Book.object.filter(price__range=[100,200])
Book.object.filter(title__contains="python")   # 筛选包含python这个字符串的内容    
Book.object.filter(title__iontains="python")   # 筛选包含python这个字符串的内容,但是不区分大小写
Book.object.filter(title__startswitch="py")
Book.object.filter(pub__date__year=2012)
Book.object.filter(pub__date__isnull=true)     # 获取为空的对象
Book.object.filter(timestamp__hour=23)
Book.object.filter(time__hour=5)
Book.object.filter(timestamp__hour__gte=12)
Book.objects.get(title__regexr'^(An?|The)+')  # 使用正则匹配    
Book.objects.get(title__iregexr'^(An?|The)+') # 使用正则匹配不区分大小写

 

3 删除表记录

删除方式就是delete(),它运行时立即删除对象而不返回任何值。例如
    model_obj.delete()
你也可以一次删除多个对象，每个QuerrySet都有一个delete()方法,它一次性删除QuerrySet中所有的对象。例如 下面代码将删除pub_date是2005年的Entry对象：
   Entry.objects.filter(pub__date__year=2005).delete()
在Django删除对象时，会模仿SQL约束ON DELETE CASCADE的行为,删除一个对象时也会删除与它相关的外键对象。例如：
    b = Blog.objecs.get(pk=1)
    b.delete()
要注意的是:delete()方法是QuerrySet上的方法,但并不适用与Manager本身。这是一种保护机制,为了避免意外的调用Entry.objects.delete()方法导致所有的记录被误删。如果确认要删除索引的对象，那么必须显式调用Entry.objects.all().delete()
如果不想级联删除，可以设置为pubHouse = models.ForeignKey(to='Publisher', on_delete=models.SET_NULL, blank=True, null=True)

4 修改表记录 

使用修改的方式与使用删除的方法类型，都是想将内容过滤后进行操作，需要注意的是update()方法对于任何结果集(QuerySet)均有效。
这意味着可以同时更新多条记录update()方法会返回一个整形数值，表示受影响的记录条数
    Book.objects.filter(title__startswitch="py").update(price=120）

 

四 ORM多表操作

1 多表关系及参数

 ForeignKey(ForeignObject) # ForeignObject(RelatedField)to,                         # 要进行关联的表名to_field=None,              # 要关联的表中的字段名称on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为- models.CASCADE，删除关联数据，与之关联也删除- models.DO_NOTHING，删除关联数据，引发错误IntegrityError- models.PROTECT，删除关联数据，引发错误ProtectedError- models.SET_NULL，删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）- models.SET_DEFAULT，删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）- models.SET，删除关联数据，a. 与之关联的值设置为指定值，设置：models.SET(值)b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)def func():return 10class MyModel(models.Model):user = models.ForeignKey(to="User",to_field="id"on_delete=models.SET(func),)
related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】    如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：# 如：- limit_choices_to={'nid__gt': 5}- limit_choices_to=lambda : {'nid__gt': 5}from django.db.models import Q- limit_choices_to=Q(nid__gt=10)- limit_choices_to=Q(nid=8) | Q(nid__gt=10)- limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')db_constraint=True          # 是否在数据库中创建外键约束parent_link=False           # 在Admin中是否显示关联数据
OneToOneField(ForeignKey)to,                         # 要进行关联的表名to_field=None               # 要关联的表中的字段名称on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为###### 对于一对一 ####### 1. 一对一其实就是 一对多 + 唯一索引# 2.当两个类之间有继承关系时，默认会创建一个一对一字段# 如下会在A表中额外增加一个c_ptr_id列且唯一：class C(models.Model):nid = models.AutoField(primary_key=True)part = models.CharField(max_length=12)class A(C):id = models.AutoField(primary_key=True)code = models.CharField(max_length=1)ManyToManyField(RelatedField)to,                         # 要进行关联的表名related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：# 如：- limit_choices_to={'nid__gt': 5}- limit_choices_to=lambda : {'nid__gt': 5}from django.db.models import Q- limit_choices_to=Q(nid__gt=10)- limit_choices_to=Q(nid=8) | Q(nid__gt=10)- limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')symmetrical=None,           # 仅用于多对多自关联时，symmetrical用于指定内部是否创建反向操作的字段# 做如下操作时，不同的symmetrical会有不同的可选字段
                                        models.BB.objects.filter(...)# 可选字段有：code, id, m1class BB(models.Model):code = models.CharField(max_length=12)m1 = models.ManyToManyField('self',symmetrical=True)# 可选字段有: bb, code, id, m1class BB(models.Model):code = models.CharField(max_length=12)m1 = models.ManyToManyField('self',symmetrical=False)through=None,               # 自定义第三张表时，使用字段用于指定关系表through_fields=None,        # 自定义第三张表时，使用字段用于指定关系表中那些字段做多对多关系表from django.db import modelsclass Person(models.Model):name = models.CharField(max_length=50)class Group(models.Model):name = models.CharField(max_length=128)members = models.ManyToManyField(Person,through='Membership',through_fields=('group', 'person'),)class Membership(models.Model):group = models.ForeignKey(Group, on_delete=models.CASCADE)person = models.ForeignKey(Person, on_delete=models.CASCADE)inviter = models.ForeignKey(Person,on_delete=models.CASCADE,related_name="membership_invites",)invite_reason = models.CharField(max_length=64)db_constraint=True,         # 是否在数据库中创建外键约束db_table=None,              # 默认创建第三张表时，数据库中表的名称

 

2 建立表结构

表结构：

class Book(models.Model):nid = models.AutoField(primary_key=True)title = models.CharField(max_length=32)publishDate = models.DateField()price = models.DecimalField(max_digits=5, decimal_places=2)
# 书籍表与出版社表建立一对多的关系publish = models.ForeignKey(to="Publish", to_field="nid", on_delete=True)
# Django自动生成多对对表的方式authors = models.ManyToManyField(to="Author")# 出版社表
class Publish(models.Model):nid = models.AutoField(primary_key=True)name = models.CharField(max_length=32)city = models.CharField(max_length=32)email = models.EmailField()# 作者表
class Author(models.Model):nid = models.AutoField(primary_key=True)name = models.CharField(max_length=32)age = models.IntegerField()# 与作者详细信息表建立一对一的关系authordetail = models.OneToOneField(to="AuthorDetail", to_field='nid', on_delete=True)# 作者详细信息表
class AuthorDetail(models.Model):nid = models.AutoField(primary_key=True)birthday = models.DateField()telephone = models.BigIntegerField()addr = models.CharField(max_length=64)# # 自己手动创建多对多表
# class Book2Author(models.Model):
#     nid = models.AutoField(primary_key=True)
#     book = models.ForeignKey(to='Book', on_delete=True)
#     author = models.ForeignKey(to='Author', on_delete=True)
# 创建联合索引class Meta：unique_together = (('author','book'))

#注意事项：
   (1) 表的名称myapp_modleName,是根据模型中的元数据自动生成的,也可以覆写为别的名称
   (2) ID字段是自动添加的
   (3) 对于外键字段，Django会在字段名上添加"_id"来创建数据库的列名
   (4) 定义好模型之后，需要在配置文件中INSTALL_APPS 中添加models所在应用名称
   (5) 外键字段ForeignKey 有一个null=True的设置(它允许外键接收空值NULL),你可以赋给它空值NONE

添加表记录

# 出版社表插入数据
Publish.objects.create(name='清华大学出版社', email="456@qq.com", city="北京")# 为book绑定出版社 book 对应publish 绑定一对多关系# 方式一Book.objects.create(title="红楼梦", price=100, publishDate='2012-12-12', publish_id=1)# 方式二    pub_obj = Publish.objects.filter(id=1) 首先查询出出版社id为的对象book_obj = Book.objects.create(title="红楼梦", price=100, publishDate='2012-12-12', publish=pub_obj)
#注意：无论是第一种方式还是第二种方式如果取出book_obj.pulish取出来的值都是与这本书籍关联的出版社对象# 为book和author绑定多对多关系表author_obj = Author.objects.create(name='alex', age=24)author_obj = Author.objects.create(name='beal', age=34)book_obj = Book.objects.create(title='三国演义', price=100, publishDate='1998-12-03', )alex = Author.objects.get(name='alex')beal = Author.objects.get(name='beal')# 绑定多对多关系的API
    book_obj.authors.add(alex,beal)或者book_obj.authors.add(1,2)或者book_Obj.authors.add(*[1,2])# 解除多对多的关系book = Book.objects.filter(nid=4).first()book.authores.remove(1)# 清除所有book.authors.clear()

 

3 基于对象的跨表查询

# 一对多查询
(1) 查询主键为1的书籍的出版社所在的城市# 一对多的正向查询 book -------- publish book_obj = Book.objects.filter(nid=1).first()print(book_obj.publish.city)(2) 查询人民出版社出版的所有书籍名称# 反向查询 publish ------- book 按表名查询 book_set.all()publish_obj = Publish.objects.filter(name="人民出版社").first()print(publish_obj.book_set.all())  # 拿到一个 queryset [book1,book2,...]# 一对一查询
(1) 查询alex的手机号# 正向查询 按字段：authodetailauthor_obj = Author.objects.filter(name='alex').first()print(author_obj.authordetail.telephone)(2) 查询手机号为911的作者的名字# 反向查询 按表名：authordetail = AuthorDetail.objects.filter(telephone=911).first()print(detail.author.name)# 多对多查询
(1) 查询三国演义所有作者的名字# 正向查询 按字段：authors  book ------> authorbook_obj = Book.objects.filter(title='三国演义').first()print(book.authors.all())
(2) alex写过的所有书籍名称反向查询 按表名 book_set.all() author ------> bookauthor_obj = Author.objects.filter(name="alex").first()print(author_obj.book_set.all())

4 基于双下划线的双表查询

(1) 查询人民出版社的所有书籍的名字和价格(一对多)ret_obj = Publish.objects.filter(name="人民出版社").values("book__title","book__price") # 以出版社为左表ret_obj = Book.objects.filter(publish__name='人民出版社').values('title','price')
(2) 查询alex出过的所有书籍的名字(多对多)Author.objects.filter(name="alex").values("book__title)Book.objects.filter(authors__name="alex"),values("title")
(3) 查询人民出版社出版过的所有书籍的名字以及作者的姓名(混合查询)Book.objects.filter(publish__name="人民出版社”).values("title","authors__name")
(4) 手机号以151开头的作者出版的所有书籍名称以及出版社名称Book.objects.filter(authors__authordetail__telephone__startswich="151").values("title","pulish__name")

五 聚合查询与分组查询

 1 聚合

 aggreate(*args, **kwargs)
    # 计算所有图书的平均价格Book.objects.all().aggreate(Avg('price'))aggreate()是QuerySet的一个终止子句，意思就是说，它返回一个包含一些键值对的字典，键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果想要为聚合值指定一个名称，可以向聚合子句提供它Book.objects.all().aggreate(averate_price=Avg('price'))结果:{'averate_price':34.35}如果你希望生成不止一个聚合,可以向aggregate()子句添加另一个参数。所以如果你还想知道所有图书价格的最大值和最小值,可以这样查询：Book.objects.aggreate('price_avg=Avg('price'),Max('price'),Min('price'))结果：{'price_avg':34.35,'price_max':Decimal('81.20'),'price_min':Decimal('12.99')}

2 单表分组

 annotate()为调用QuerySet中每一个对象都生成一个独立的统计值(统计方法用聚合函数)(1) 统计每一本书的作者个数Book.objects.all().annotate(Count("authors__name"))    # 返回的仍然是query-set，但是每个对象会以键值的方式添加统计结果(2) 统计每一个作者出版过的书籍最高价格Author.objects.all().annotate(Max(book__price))(3) 统计每一个出版社出版过的书籍的平均价格Publish.objects.all().annotate(Avg("book__price"))(4) 查询每一个本门的名称以及员工的平均薪水Emp.objects.values("dep").annotate(avr_salary=Avg("salary"))(5) 查询每一个省份的名称以及对应的员工数# 在单表分组下，按照住进进行group by是没有任何意义的Emp.objects.values("provience").annotate(c=count("id"))

3 多表分组

  (1) 查询每一个出版社的名称以及出版的书籍个数Publish.objects.values("id").annotate(Count("book__title"))Publish.objects.values("name").annotate(Count("book__title"))Publish.objects.values("name").annotate(Count("book__title")).values("name", "c")(2) 查询每一个作者的名字以及出版过的书籍的最高价格# pk == 主键Author.objects.value("pk").annotate(Max("book__price"))(3) 查询每一个书籍的名称以及对应的作者个数Book.objects.values("pk").annotate(c=Count("author__name")).values("title", "c")(4) 统计每一本以py开头的书籍的作者个数Book.objects.filter(title__startswitch="py").values("pk").annotate(c=Count("authors__name")).values("title", "c")(5) 统计不止一个作者的图书Book.objects.values("pk").annotate(c=Count("authors__name)).filter(c__gt=1).values

 

六 其他扩展查询方法

1 F查询和Q查询

(1) F查询
如果我们要对两个字段的值做比较那么Django提供了F()方法来比较同一个model实例中两个不同字段的值

# 查询评论数大于收藏数的书籍
from django.db.models import F
Book.objects.filter(commnetNum__lt=F('keepNum'))
# 查询评论数大于收藏数2倍的书籍
Book.objects.fitler(commnetNum__lt=F('keepNum')*2)
# 将每一本书的价格提高30元Book.objects.all().updatae(price=F("price")+30)

 

(2) Q查询
filter()等方法中的关键字参数查询都是一起进行的"AND"。如果需要执行更复杂的查询(例如OR语句)可以使用Q，Q对象可以使用&和|操作符组合起来。当一个操作符在两个Q对象上使用时它产生一个新的Q对象

 from djano.db.models impor Q
# 方式一book_list = Book.objects.filter(Q(authors__name="harry")|Q(authors__name)="caishuang")      
同时，Q对象可以使用~操作符取反, 这允许组合正常的查询和取反(NOT)查询：book_list = Book.objects.filter(Q(authors__name="harry")) & ~Q(publishDate__year=2017).values("title")          
查询函数可以混合使用Q对象和关键字参数。所有提供给查询函数的参数(关机簪子参数或Q对象)都将"AND"在一起, 但是,如果出现Q对象，它必须位于所有关键字参数的前面bookList = Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017),title__icontains="python")            # 方式二：# con = Q()# q1 = Q()# q1.connector = 'OR'# q1.children.append(('id', 1))# q1.children.append(('id', 10))# q1.children.append(('id', 9))# q2 = Q()# q2.connector = 'OR'# q2.children.append(('c1', 1))# q2.children.append(('c1', 10))# q2.children.append(('c1', 9))# con.add(q1, 'AND')# con.add(q2, 'AND')#
        # models.Tb1.objects.filter(con)

2 extra查询

# extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
# Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
# Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
# Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
# Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])

示例：
# 查询当前站点每一个年月的名称以及对应的文章数  mysql:data_formant   sqlite:strftime
data_list = models.Article.objects.extra(select={"y_m_date":"date_format(create_time,'%%Y-%%m')"}).values("y_m_date").annocate(c=Count("nid")).values("y_m_date","c")

3 性能相关查询

(1) select_related
　　 # 注意如果连表多性能会越来越差，只支持OneToOne和foreignkey字段表之间进行join连表操作，一次性获取关联的数据model.tb.objects.all().select_related()model.tb.objects.all().select_related("外键字段")model.tb.objects.all().select_related("外键字段__外键字段")(2) prefetch_related
　　 额外还支持ManyToMany多表连表操作时速度会慢，使用其执行多次SQL查询在Python中实现连表操作。 先查询想要的数据然后构建条件 如: id = [1,2,3],再次查询其他表根据id做条件model.tb.objects.all().prefetch_related("外键字段")

 

 

4 Django实现原生SQL查询

def raw(self, raw_query, params=None, translations=None, using=None):# 执行原生SQLmodels.UserInfo.objects.raw('select * from userinfo')# 如果SQL是其他表时，必须将名字设置为当前UserInfo对象的主键列名models.UserInfo.objects.raw('select id as nid from 其他表')# 为原生SQL设置参数models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,])# 将获取的到列名转换为指定列名name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}Person.objects.raw('SELECT * FROM some_other_table', translations=name_map)# 指定数据库models.UserInfo.objects.raw('select * from userinfo', using="default")################### 原生SQL ###################from django.db import connection, connectionscursor = connection.cursor()  # cursor = connections['default'].cursor()cursor.execute("""SELECT * from auth_user where id = %s""", [1])row = cursor.fetchone() # fetchall()/fetchmany(..)

# ps 选择数据库
　　querryset = models.Userinfo.objects.useing('default').all()