orm用法,orm创建表
一般操作
必须知道的13个规则1 all():查询所有结果。
2 (* * kwargs):它包含符合给定过滤标准的对象。
Get (* * kwargs):返回符合给定过滤条件的对象。只有一个返回结果，如果有多个对象或没有对象符合筛选条件，将会引发错误。
4 exclude(**kwargs):它包含不符合给定过滤标准的对象。
5 values(*field):返回一个ValueQuerySet——特殊的QuerySet。运行后，你得到的不是一系列模型的实例化对象，而是一个迭代的字典序列。
6 values_list(*field):与values()非常相似，它返回一个元组序列，values返回一个字典序列。
7 _ by (* field):对查询结果进行排序。
8 reverse():将查询结果反向排序。请注意，reverse()只能在具有已定义顺序的QuerySet上调用(在模型类的元中指定顺序或调用order_by()方法)。
9 distinct():从返回的结果中消除重复记录(如果您的查询跨越多个表，则在计算QuerySet时可能会得到重复的结果。此时可以使用distinct()。请注意，仅PostgreSQL支持按字段重复数据删除。)
0count():返回数据库中与查询匹配的对象数。
1first():返回第一条记录。
1Last():返回最后一条记录。
1exists():如果QuerySet包含数据，则返回True，否则返回False。有所有()方法返回QuerySet对象。
过滤器()
排除()
order_by()
反向()
独特()
的特殊QuerySetvalues()返回迭代字典序列。
Values_list()返回祖先的迭代序列。
返回具体对象的get()。
首先()
最后一个()
返回布尔值的方法有：exists()
返回数字的方法是count()
单表查询的神奇双下划线#大于和小于。
#
# models . tb1 . objects . filter(id _ _ gt=1)#获取ID大于1的值
# models . tb1 . objects . filter(id _ _ GTE=1)#获取ID大于或等于1的值
# models . tb1 . objects . filter(id _ _ lt=10)#获取ID小于10的值
# models . tb1 . objects . filter(id _ _ LTE=10)#获取ID小于10的值
# models . tb1 . objects . filter(id _ _ lt=10，ID _ _ gt=1) #获取ID大于1小于10的值
#英寸
#
# models . tb1 . objects . filter(id _ _ in=[11，22，33]) #获取ID等于11，22，33的数据
#型号。Tb1.objects.exclude(id__in=[11，22，33]) # not in
#包含
# models . tb1 . objects . filter(name _ _ contains= ven )#获取其名称字段包含 ven 的
# models . tb1 . objects . filter(name _ _ icontains= ven )# icontains不区分大小写。
#范围
# models . tb1 . objects . filter(id _ _ range=[1，3])# id的范围是1到3，相当于SQL的bettwen和。
类似的有：startswith，istartswith，endswith，iendswith。
# date字段还可以：
# models . class . objects . filter(first _ day _ _ year=2017)单表查询练习1。创建数据库
创建数据库表单；2.模型文件
从django.db导入模型
类人(模特。型号):
名称=型号。CharField(max_length=32)
年龄=模特。IntegerField()
生日=模特。日期字段()3。将以下内容添加到数据表中
4.工程目录下的orm练习文件
导入操作系统
if __name__==__main__ :
OS . environ . set default( DJANGO _ SETTINGS _ MODULE ， day8_15ORM.settings )
进口django
django.setup()
从app01导入模型
#所有人查询所有人
ret=模型。Person.objects.all()
打印(ret)
#//query set[人：人-对象：张三，人：人-对象：李四，人：人-对象：王五，人：人-对象：小黑，人：人-对象：小白，人：人-对象：黄晓]
# get指定查询
ret=模型。Person.objects.get(id=2)
打印(ret)
#//人-物：李四
#过滤器
#即使查询只有一个结果，返回的结果也是QuerySet，我们需要索引第一个元素。
ret=模型。Person.objects.filter(id=2)
打印(ret)
#//query set[person:person-object:李四]
#如果你想获取指定的元素，你需要遍历索引
ret=模型。Person.objects.filter(id=2)[0]
打印(ret)
#//人-物：李四
#不会返回空的QuerySet，也不会报告错误。
ret=模型。Person.objects.filter(id=20)
打印(ret)
#//QuerySet []
#排除#查询除了编号值为一的所有人
ret=模型Person.objects.exclude(id=1)
打印(退休)
#//QuerySet [人员：人员-对象：李四，人：人-物：王五，人：人-物：小黑，人：人-物：小白，人：人-物：小黄]
#值#根据指定字段查询，返回的是一个查询对象，里面都是字典。
ret=模型Person.objects.values(name )
打印(退休)
#//QuerySet [{name :张三},{ 姓名: 李四},{ 姓名: 王五},{ 姓名: 小黑},{ 姓名: 小白},{ 姓名: 小黄}]
# 如果不写值，默认查询所有
ret=模型Person.objects.values()
打印(退休)
#//QuerySet [{id: 1， name :张三，年龄:10,生日：datetime.date(2008，8，5)}，{id: 2，姓名: 李四，年龄:20,生日：datetime.date(1998，6，2)}，{id: 3，姓名: 王五，年龄:30,生日：datetime.date(1988，3，2)}，{id: 4，姓名: 小黑，年龄:40,生日：datetime.date(1978，11，14)}，{id: 5，姓名: 小白，年龄:12,生日：datetime.date(2006，2，7)}，{id: 6，姓名: 小黄，年龄:50,生日：datetime.date(1968，5，20)}]
# values_list #通价值观念一样，只是返回的里面是元组
ret=模型100人。对象。值列表(名称)
打印(退休)
#//QuerySet [(张三,), (李四,), (王五,), (小黑,), (小白,), (小黄,)]
# 如果不写值，默认查询所有
ret=模型Person.objects.values_list()
打印(退休)
#//QuerySet [(1，张三，10，datetime.date(2008，8，5))，(2，李四，20，datetime.date(1998，6，2))，(3，王五，30，datetime.date(1988，3，2))，(4，小黑，40，datetime.date(1978，11，14))，(5，小白，12，datetime.date(2006，2，7))，(6，小黄，50，datetime.date(1968，5，20))]
#排序依据对查询结果按照指定字段排序，根据年龄排序
ret=模型Person.objects.all().order_by(年龄)
打印(退休)
#//QuerySet [人员：人员-对象：张三，人：人-物：小白，人：人-物：李四，人：人-物：王五，人：人-物：小黑，人：人-物：小黄]
#反转根据年龄排序，再进行反转
ret=模型Person.objects.all().order_by(年龄).反向()
打印(退休)
#//QuerySet [人员：人员-对象：小黄，人：人-物：小黑，人：人-物：王五，人：人-物：李四，人：人-物：小白，人：人-物：张三]
#计数统计匹配查询的对象数量
ret=模型Person.objects.all().计数()
打印(退休)
#//6
#首先查询第一条记录
ret=模型Person.objects.first()
打印(退休)
#//人-对象：张三
#最后查询最后一条记录
ret=模型Person.objects.last()
打印(退休)
#//人-对象：小黄
#存在判断表中是否有数据
ret=模型Person.objects.exists()
打印(退休)
#//真
单表查询之神奇的双下划綫
# 查询编号值大于一小于四的结果
ret=模型Person.objects.filter(id__gt=1，id__lt=4)
打印(退休)
#//QuerySet [人员：人员-对象：李四，人：人-物：王五]
#英寸查询编号值在[1, 3, 5, 7]中的结果
ret=模型100人。对象。筛选器(id _ _ in=[1，3，5，7])
打印(退休)
#//QuerySet [人员：人员-对象：张三，人：人-物：王五，人：人-物：小白]
#不在
ret=模型100人。对象。exclude(id _ _ in=[1，3，5，7])
打印(退休)
#//QuerySet [人员：人员-对象：李四，人：人-物：小黑，人：人-物：小黄]
#包含查询名字字段包含三的
ret=模型100人。对象。过滤器(名称_ _包含=三)
打印(退休)
#//QuerySet [人员：人员-对象：张三]
#范围查询编号范围在一到3之间的
ret=模型100人。对象。过滤器(id _ _ range=[1，3])
打印(退休)
#//QuerySet [人员：人员-对象：张三，人：人-物：李四，人：人-物：王五]
# 日期和时间字段还可以有以下写法
ret=模型Person.objects.filter(生日_ _年=2008)
打印(退休)
#//QuerySet [人员：人员-对象：张三]
# 根据月查询
ret=模型Person.objects.filter(生日_ _月=6)
打印(退休)
#//QuerySet [人员：人员-对象：李四] orm.py
一对一字段一对一从django.db导入模型
类作者（模型。型号):
名称=型号CharField(max_length=32)
信息=模型OneToOneField(to=AuthorInfo )
类别AuthorInfo(型号。型号):
电话=模型CharField(max_length=11)
邮件=模特。电子邮件字段()正向查询author_obj=models .Author.objects.get(id=1)
打印(作者对象名称)#查找编号为一的用户的名字
# 查询关联表时这里的信息是根据模型中关联的字段的名称来查询
打印(作者_对象.信息.电话)#查找编号为一的用户的电话
打印(author_obj.info.email) #查找编号为一的用户的邮箱反向查询author_obj=models .AuthorInfo.objects.get(id=1)
打印(作者_对象.电子邮件)#查找编号为一的用户的邮箱
打印(作者_对象.电话)#查找编号为一的用户的电话
# 反向查询是作者是根据模型中表名（类名)来查询
打印(作者对象作者姓名)#查找编号为一的用户的名字外键一对多正向查找对象查找（跨表)语法：
对象。关联字段。字段
示例：
模型.Book.objects.first() #第一本书对象
print(book_obj.publisher) #得到这本书关联的出版社对象
print(book _ obj。出版商。姓名)#得到出版社对象的名称字段查找（跨表)语法：
关联字段__字段
示例：
打印（型号10 .书。对象。values _ list( publisher _ _ name ))反向操作对象查找语法：
obj .表名_设置
示例：
publisher_obj=models .Publisher.objects.first() #找到第一个出版社对象
图书=publisher _ obj。书_集。all()#找到第一个出版社出版的所有书
标题=书籍。值列表(标题)#找到第一个出版社出版的所有书的书名字段查找语法：
表名__字段
示例：
头衔=模特出版商。对象。values _ list( book _ _ title )一对多关联查询练习
从django.db导入模型
类发行者（模型。型号):
名称=型号CharField(max_length=64，unique=True)
课堂用书（模型。型号):
标题=模型CharField(max_length=64) #书名
价格=车型. DecimalField(max_digits=5，decimal_places=2，默认值=19.99) #价格
# 外键
# related_name=books 反向查询是用来代替book_set的
发布者=模型ForeignKey(to=Publisher ，on_delete=models .CASCADE，related_name=books ，null=True)模型。巴拉圭
向表里添加数据
出版社表及书籍表的对应关系
导入操作系统
if __name__==__main__ :
OS。环境。设置默认值( DJANGO _ SETTINGS _ MODULE ， day 8 _ 15 RM . SETTINGS )
进口框架
django.setup()
从app01导入模型
# 说明：#//行内容是打印的输出结果
# 外键的查询操作
# 正向查询
# 基于对象跨表查询
模型.Book.objects.first() #查询的书对象
print(book_obj.publisher) #和我这本书关联的出版社对象
#//发布者对象
print(book _ obj。出版商。姓名)#得到出版社对象的名字
#//西丽出版社
# 基于字段跨表查询
# 查询编号是一的书的出版社的名称
打印（型号Book.objects.filter(id=1)。values _ list( publisher _ _ name )#得到出版社对象的名字
#//西丽出版社
# 反向查询
# 基于对象跨表查询
# 方法一：如果莫德莱斯中的表结构的外键类型中保函了相关名称属性可以使用下面的方法进行查询。related_name=books ，
publisher_obj=models .Publisher.objects.get(id=1) #查询的出版社对象
图书=publisher _ obj。书籍。all()#得到出版社对应的所有书籍
打印（书籍[0])。标题)#取出第一本书的名字
#//Python中国
# 方法二：没有指定相关名称
publisher_obj=models .Publisher.objects.get(id=1) #查询的出版社对象
图书=publisher _ obj。书_集。all()#得到出版社对应的所有书籍
打印（书籍[0])。标题)#取出第一本书的名字
# 基于字段跨表查询
书籍=模型Publisher.objects.filter(id=1).values_list(book__title) #查询编号为一的出版社的书籍
打印（书籍)orm.py
多对多字段多对多类相关管理器关联管理器是在一对多或者多对多的关联上下文中使用的管理器。
它存在于下面两种情况：
外键关系的反向查询多对多关联关系简单来说就是当点后面的对象可能存在多个的时候就可以使用以下的方法。
方法创建()
创建一个新的对象，保存对象，并将它添加到关联对象集之中，返回新创建的对象。
导入日期时间
模特Author.objects.first().book_set.create(title=番茄物语，发布日期=日期时间。约会。今日())添加()
把指定的模型对象添加到关联对象集中。
添加对象
作者_对象=模型Author.objects.filter(id__lt=3)
模特10 .书。对象。第()位作者。添加(* author _ objs).添加编号
模特10 .书。对象。第()位作者。add(*[1，2])集合()
更新模型对象的关联对象。
模型.Book.objects.first()
book_obj.authors.set([2，3])remove()
从关联对象集中移除执行的模型对象
模型.Book.objects.first()
book _ obj。作者。移除(3)清除()
从关联对象集中移除一切对象。
模型.Book.objects.first()
book_obj.authors.clear()注意：
对于外键对象，清除()和移除()方法仅在null=True时存在。
举个例子：
外键字段没设置null=True时，
课堂用书（模型。型号):
标题=模型CharField(max_length=32)
发布者=模型ForeignKey(to=Publisher)没有清除()和移除()方法：
模特Publisher.objects.first().book_set.clear()
回溯（最近一次呼叫):
模块中文件"输入"的第一行
属性错误：“相关经理”对象没有属性"清除"当外键字段设置null=True时，
课堂用书（模型。型号):
名称=型号CharField(max_length=32)
发布者=模型ForeignKey(to=Class，null=True)此时就有清除()和移除()方法：
模特Publisher.objects.first().book_set.clear()注意：
对于所有类型的关联字段，添加()、创建()、删除()和清除(),设置()都会马上更新数据库。换句话说，在关联的任何一端，都不需要再调用保存()方法。聚合查询和分组查询聚合聚合()是查询的一个终止子句，意思是说，它返回一个包含一些键值对的字典。
键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。
用到的内置函数：
从django.db.models导入平均值、总和、最大值、最小值、计数示例：
从django.db.models导入平均值、总和、最大值、最小值、计数
模特Book.objects.all().合计（平均值(价格))
{price__avg: 13.233333}如果你想要为聚合值指定一个名称，可以向聚合子句提供它。
模特10 .书。对象。聚合(average _ price=Avg( price ))
{ 平均价格:13.233333}如果你希望生成不止一个聚合，你可以向聚合()子句中添加另一个参数。所以，如果你也想知道所有图书价格的最大值和最小值，可以这样查询：
模特Book.objects.all().汇总（平均值(价格)、最大值(价格)、最小值(价格)
{price__avg: 13.233333， price__max: Decimal(19.90 )， price__min: Decimal(9.90)}分组我们在这里先复习一下结构化查询语言语句的分组。
假设现在有一张公司职员表：
我们使用原生结构化查询语言语句，按照部分分组求平均工资：
按部门从员工组中选择部门、AVG(薪资);对象关系映射(对象关系映射)查询：
从django.db.models导入平均值
Employee.objects.values("部门")。annotate(avg=Avg(salary ).值（部门，"平均值")连表查询的分组：
结构化查询语言查询：
挑选部门名称，AVG(薪金)从员工内部联接部门on(员工。dept _ id=dept . id)group by dept _ id；对象关系映射(对象关系映射)查询：
从django.db.models导入平均值
模特部门对象。annotate(Avg=Avg(雇员_ _薪金)).值(名称,平均值)更多示例：示例1:统计每一本书的作者个数
book_list=模特.Book.objects.all().批注(author _ num=Count( author ))
对于book_list中的对象：
.打印(对象作者编号)
.
2
一个
1例2:计算每个出版社买的最便宜的书的价格。
publisher_list=models。publisher . objects . annotate(Min _ price=Min( book _ _ price ))
对于publisher_list中的对象：
.打印(对象最小价格)
.
9.90
19.90方法2:
模特。book . objects . values( publisher _ _ name )。annotate(min_price=Min(price ))
QuerySet [{publisher__name :沙河出版社， min _ price: decimal (9.90)}，{publisher__name :人民出版社， min_price: Decimal(19.90)}]例3
模特。book . objects . annotate(author _ num=Count( author ))。过滤器(作者数量__gt=1)
QuerySet [Book: Tomato Story]例4:根据一本书的作者数量对查询集QuerySet进行排序。
模特。book . objects . annotate(author _ num=Count( author ))。order_by(author_num )
QuerySet【书：香蕉的故事，书：橘子的故事，书：番茄的故事】例5:查询各个作者出版的书的总价。
模特。author . objects . annotate(Sum _ price=Sum( book _ _ price ))。值(名称，价格总和)
QuerySet [{name: elf ， sum _ price: decimal (9.90)}，{name: fairy ， sum _ price: decimal (29.80)}，{name: witch。如果要比较两个字段的值，应该怎么做？
Django提供了f()来做这样的比较。f()的实例可以引用查询中的字段，以比较同一模型实例中两个不同字段的值。
示例1:
评论比收藏多的书
从django.db.models导入F
models . book . objects . filter(commnet _ num _ _ gt=f( keep _ num ))Django支持f()对象之间以及f()对象与常量之间的加、减、乘、除、模运算。
models . book . objects . filter(commnet _ num _ _ lt=f( keep _ num )* 2)修改操作也可以使用f函数，比如每本书提价30元。
Models.book.objects.all()。更新(价格=f(价格)30)扩展：
如果要修改char字段呢？
例如，在所有标题后添加(第一版)。
从django.db.models.functions导入Concat
从django.db.models导入值
Models.book.objects.all()。Update (title=concat (f (title )、value()、value (first edition )、value ()) Q query filter()等方法都是“与”在一起。如果需要执行更复杂的查询(比如OR语句)，可以使用Q对象。
示例1:
质疑作者的名字是仙女的还是女巫的
models . book . objects . filter(Q(authors _ _ name= fairies ) Q(authors _ _ name= witches ))您可以组合and 运算符，并使用括号进行分组，以编写任何复杂的Q对象。同时，Q对象可以被~运算符求反，这允许普通查询和NOT查询的组合。
例：查询作者名字是仙女而不是2018年出版的书名。
models . book . objects . filter(q(author _ _ name=仙女)~ q (publish _ date _ _ year=2018))。值列表(标题)
QuerySet [(番茄故事，)]查询函数可以混合q对象和关键字参数。提供给查询函数的所有参数(关键字参数或Q对象)将一起进行“与”运算。但是，如果出现Q对象，它必须在所有关键参数之前。
比如查询所有出版年份为2017年或2018年，书名中有故事的书。
models . book . objects . filter(Q(publish _ date _ _ year=2018) Q(publish _ date _ _ year=2017)，title _ _ I contains= story )
query set[书：番茄的故事，书：香蕉的故事，书：橘子的故事]事务导入os
if __name__==__main__ :
OS . environ . set default( DJANGO _ SETTINGS _ MODULE ， BMS.settings )
进口django
django.setup()
导入日期时间
从app01导入模型
尝试：
从django.db导入事务
with transaction.atomic():
new _ publisher=models . publisher . objects . create(name= Mars Press )
models . book . objects . create(title= Orange Story ，publish _ date=datetime . date . today()，publisher _ id=10) #指定一个不存在的发布者id
例外情况为e:
打印（字符串(e))其他鲜为人知的操作（有个印象即可)姜戈奥姆执行原生SQL# extra
# 在查询的基础上继续执行子语句
# extra(self，select=None，where=None，params=None，tables=None，order_by=None，select_params=None)
#选择和select_params是一组，在哪里和参数是一组，表格用来设置从哪个表
#入口。对象。extra(select={ new _ id : select col from sometable where other col % s }，select_params=(1，))
# Entry.objects.extra(其中=[headline=%s]，params=[Lennon])
# Entry.objects.extra(其中=[foo=a 或bar=a ， baz=a])
#入口。对象。extra(select={ new _ id : select id from TB where id % s }，select_params=(1，)，order_by=[-nid])
举个例子：
模特UserInfo.objects.extra(
select={ newid : select count(1)from app 01 _ usertype where id % s }，
select_params=[1，]，
其中=[年龄“% s”]，
params=[18，]，
order_by=[-age]，
tables=[app01_usertype]
)
挑选
app01_userinfo.id，
（从app01 _用户类型中选择计数(1)，其中编号为1)作为新闻编号
来自应用01 _用户信息，应用01 _用户类型
在哪里
app 01 _用户信息。18岁
以.排序
app01_userinfo.age desc
# 执行原生结构化查询语言
# 更高灵活度的方式执行原生结构化查询语言语句
#从django.db导入连接，连接
# cursor=连接。cursor()# cursor=connections[ default ].光标()
#光标。执行( SELECT * from auth _ user，其中id=%s ，[1])
# row=cursor.fetchone()QuerySet方法大全
##################################################################
#改变属性并返回新查询集的公共方法#
##################################################################
定义全部（自己)
# 获取所有的数据对象
定义过滤器(self，*args，**kwargs)
# 条件查询
# 条件可以是：参数，字典，问
def exclude(self，*args，**kwargs)
# 条件查询
# 条件可以是：参数，字典，问
定义选择相关的(自身，*字段)
性能相关：表之间进行加入连表操作，一次性获取关联的数据。
总结：
1.选择_相关主要针一对一和多对一关系进行优化。
2.选择_相关使用结构化查询语言的加入语句进行优化，通过减少结构化查询语言查询的次数来进行优化、提高性能。
定义预取相关（自身，*查找)
性能相关：多表连表操作时速度会慢，使用其执行多次结构化查询语言查询在计算机编程语言代码中实现连表操作。
总结：
1.对于多对多字段(ManyToManyField)和一对多字段，可以使用预取相关()来进行优化。
2.预取相关()的优化方式是分别查询每个表，然后用计算机编程语言处理他们之间的关系。
定义注释(self，*args，**kwargs)
# 用于实现聚合分组依据查询
从django.db.models导入计数、平均值、最大值、最小值和总和
v=模型UserInfo.objects.values(u_id ).批注(uid=Count(u_id ))
# SELECT u_id，COUNT(ui)AS ` uid ` FROM UserInfo GROUP BY u _ id
v=模型UserInfo.objects.values(u_id ).annotate(uid=Count(u_id ).过滤器(uid__gt=1)
# SELECT u_id，COUNT(ui _ id)AS ` uid ` FROM UserInfo GROUP BY COUNT(u _ id)为一的u _ id
v=模型UserInfo.objects.values(u_id ).annotate(uid=Count(u_id ，distinct=True)).过滤器(uid__gt=1)
# SELECT u_id，COUNT(DISTINCT ui _ id)AS ` uid ` FROM UserInfo GROUP BY COUNT(u _ id)为一的u _ id
定义不同(自身，*字段名称)
# 用于明显的去重
模特UserInfo.objects.values(nid ).独特()
#从用户信息中选择不同的突边
注：只有在一种数据库系统中才能使用明显的进行去重
def order_by(自身，*字段名称)
# 用于排序
模特UserInfo.objects.all().order_by(-id ，年龄)
def extra(self，select=None，where=None，params=None，tables=None，order_by=None，select_params=None)
# 构造额外的查询条件或者映射，如：子查询
入口。对象。extra(select={ new _ id : select col from sometable where other col % s }，select_params=(1，))
Entry.objects.extra(其中=[headline=%s]，params=[Lennon])
Entry.objects.extra(其中=[foo=a 或bar=a ， baz=a])
入口。对象。extra(select={ new _ id : select id from TB where id % s }，select_params=(1，)，order_by=[-nid])
定义反转（自身):
# 倒序
模特UserInfo.objects.all().order_by(-nid ).反向()
# 注：如果存在order_by反向则是倒序，如果多个排序则一一倒序
定义延期（自身，*字段):
模特UserInfo.objects.defer(用户名， id )
或
模特UserInfo.objects.filter(.).延期(用户名， id )
#映射中排除某列数据
仅定义（自身，*字段):
#仅取某个表中的数据
模特UserInfo.objects.only(用户名， id )
或
模特UserInfo.objects.filter(.).仅(用户名， id )
定义使用（自身，别名):
指定使用的数据库，参数为别名（设置中的设置)
##################################################
#返回查询子类的公共方法#
##################################################
def raw(self，raw_query，params=None，translations=None，using=None):
# 执行原生结构化查询语言
模特userinfo。对象。raw(“从用户信息中选择*”)
# 如果结构化查询语言是其他表时，必须将名字设置为当前用户信息对象的主键列名
模特userinfo。对象。raw(选择id作为NID来源其他表)
# 为原生结构化查询语言设置参数
模特userinfo。对象。raw(从userinfo中选择id作为NID，其中NID % s ，params=[12，])
# 将获取的到列名转换为指定列名
name_map={first: first_name ， last: last_name ， bd: birth_date ， pk: id}
人。对象。raw( SELECT * FROM some _ other _ table ，translations=name_map)
# 指定数据库
模特userinfo。对象。raw(“select * from userinfo”，using=“default”)
################### 原生SQL ############
从django.db导入连接，连接
cursor=connection.cursor() # c
ursor = connections[default].cursor()
cursor.execute("""SELECT * from auth_user where id = %s""", [1])
row = cursor.fetchone() # fetchall()/fetchmany(..)
def values(self, *fields):
# 获取每行数据为字典格式
def values_list(self, *fields, **kwargs):
# 获取每行数据为元祖
def dates(self, field_name, kind, order=ASC):
# 根据时间进行某一部分进行去重查找并截取指定内容
# kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
# order只能是："ASC" "DESC"
# 并获取转换后的时间
- year : 年-01-01
- month: 年-月-01
- day : 年-月-日
models.DatePlus.objects.dates(ctime,day,DESC)
def datetimes(self, field_name, kind, order=ASC, tzinfo=None):
# 根据时间进行某一部分进行去重查找并截取指定内容，将时间转换为指定时区时间
# kind只能是 "year", "month", "day", "hour", "minute", "second"
# order只能是："ASC" "DESC"
# tzinfo时区对象
models.DDD.objects.datetimes(ctime,hour,tzinfo=pytz.UTC)
models.DDD.objects.datetimes(ctime,hour,tzinfo=pytz.timezone(Asia/Shanghai))
"""
pip3 install pytz
import pytz
pytz.all_timezones
pytz.timezone(‘Asia/Shanghai’)
"""
def none(self):
# 空QuerySet对象
####################################
# METHODS THAT DO DATABASE QUERIES #
####################################
def aggregate(self, *args, **kwargs):
# 聚合函数，获取字典类型聚合结果
from django.db.models import Count, Avg, Max, Min, Sum
result = models.UserInfo.objects.aggregate(k=Count(u_id, distinct=True), n=Count(nid))
=== {k: 3, n: 4}
def count(self):
# 获取个数
def get(self, *args, **kwargs):
# 获取单个对象
def create(self, **kwargs):
# 创建对象
def bulk_create(self, objs, batch_size=None):
# 批量插入
# batch_size表示一次插入的个数
objs = [
models.DDD(name=r11),
models.DDD(name=r22)
]
models.DDD.objects.bulk_create(objs, 10)
def get_or_create(self, defaults=None, **kwargs):
# 如果存在，则获取，否则，创建
# defaults 指定创建时，其他字段的值
obj, created = models.UserInfo.objects.get_or_create(username=root1, defaults={email: 1111111,u_id: 2, t_id: 2})
def update_or_create(self, defaults=None, **kwargs):
# 如果存在，则更新，否则，创建
# defaults 指定创建时或更新时的其他字段
obj, created = models.UserInfo.objects.update_or_create(username=root1, defaults={email: 1111111,u_id: 2, t_id: 1})
def first(self):
# 获取第一个
def last(self):
# 获取最后一个
def in_bulk(self, id_list=None):
# 根据主键ID进行查找
id_list = [11,21,31]
models.DDD.objects.in_bulk(id_list)
def delete(self):
# 删除
def update(self, **kwargs):
# 更新
def exists(self):
# 是否有结果
QuerySet方法大全QuerySet方法大全
Django终端打印SQL语句LOGGING = {
version: 1,
disable_existing_loggers: False,
handlers: {
console:{
level:DEBUG,
class:logging.StreamHandler,
},
},
loggers: {
django.db.backends: {
handlers: [console],
propagate: True,
level:DEBUG,
},
}
}即为你的Django项目配置上一个名为django.db.backends的logger实例即可查看翻译后的SQL语句。
在Python脚本中调用Django环境import os
if __name__ == __main__:
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")
import django
django.setup()
from app01 import models
books = models.Book.objects.all()
print(books)
人生是条无名的河，是浅是深都要过；人生是杯无色的茶，是苦是甜都要喝；人生是首无畏的歌，是高是低都要唱。
© ©
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。