Django Model
1. 模型规则
- 一个模型通常对应数据库中的一张表
- 每一个模型都是一个继承 django.db.models.Model 的类
- 模型的每一个属性代表一个数据表的字段
- 定义好模型后，django可以自已通过API去访问数据库
- 定义字段的名字不要和models API重名 如clean, save, delete
定义好模型后，在设置文件中INSTALLED_APPS中加入app
然后执行数据库迁移命令，创建数据表
python manager.py makemigrations
python manager.py migrate
2. 字段和选项
2.1 字段
字段是用来定义数据表字段的存储类型
渲染表单时，选择合适的组件
在admin和产生表单时，做一些基本的验证
2.2 字段命名规则
不要使用python关键字
不要包含两个及以上的下划线
不要以下划线结尾
2.3 字段类型
AutoField(Field) - int自增列，必须填入参数 primary_key=True BigAutoField(AutoField) - bigint自增列，必须填入参数 primary_key=True 注：当model中如果没有自增列，则自动会创建一个列名为id的列 from django.db import models class 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 ～ 32767 PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField) - 正小整数 0 ～ 32767 IntegerField(Field) - 整数列(有符号的) -2147483648 ～ 2147483647 PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField) - 正整数 0 ～ 2147483647 BigIntegerField(IntegerField): - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807 BooleanField(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中提供验证 URL SlugField(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.FileSystemStorage ImageField(FileField) - 字符串，路径保存在数据库，文件上传到指定目录 - 参数： upload_to = "" 上传文件的保存路径 storage = None 存储组件，默认django.core.files.storage.FileSystemStorage width_field=None, 上传图片的高度保存的数据库字段名（字符串） height_field=None 上传图片的宽度保存的数据库字段名（字符串） DateTimeField(DateField) - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] DateField(DateTimeCheckMixin, Field) - 日期格式 YYYY-MM-DD TimeField(DateTimeCheckMixin, Field) - 时间格式 HH:MM[:ss[.uuuuuu]] DurationField(Field) - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型 FloatField(Field) - 浮点型 DecimalField(Field) - 10进制小数 - 参数： max_digits，小数总长度 decimal_places，小数位长度 BinaryField(Field) - 二进制类型 字段列表
字段类型对应数据库类型
'AutoField': 'integer AUTO_INCREMENT', 'BigAutoField': 'bigint AUTO_INCREMENT', 'BinaryField': 'longblob', 'BooleanField': 'bool', 'CharField': 'varchar(%(max_length)s)', 'CommaSeparatedIntegerField': 'varchar(%(max_length)s)', 'DateField': 'date', 'DateTimeField': 'datetime', 'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)', 'DurationField': 'bigint', 'FileField': 'varchar(%(max_length)s)', 'FilePathField': 'varchar(%(max_length)s)', 'FloatField': 'double precision', 'IntegerField': 'integer', 'BigIntegerField': 'bigint', 'IPAddressField': 'char(15)', 'GenericIPAddressField': 'char(39)', 'NullBooleanField': 'bool', 'OneToOneField': 'integer', 'PositiveIntegerField': 'integer UNSIGNED', 'PositiveSmallIntegerField': 'smallint UNSIGNED', 'SlugField': 'varchar(%(max_length)s)', 'SmallIntegerField': 'smallint', 'TextField': 'longtext', 'TimeField': 'time', 'UUIDField': 'char(32)',
2.3 字段选项
- null
True-字段可以用NULL存储空内容
- blank
True-字段可以为空， blank是django校验的时候判断的，null是数据库判断的
- choices
可以设置一个2个元素的元组列表
元组中第一个元素是存储到数据库中的字段
元组中第二个元素是用来在表单中显示的
设置好后该字段只能在choices列表中选择值
模型对象 可以通过 get_字段名_display()访问元组中第二个字段
class AppVersion(models.Model): ANDROID = 1 IOS = 2 APP_CHOICE = ( (ANDROID, 'Android'), (IOS, 'IOS') )
app = models.PositiveIntegerField(choices=APP_CHOICE, verbose_name='平台', default=ANDROID)
def __str__(self):
return "<AppVersion>:%s-%s" %(self.get_app_display(), self.version_number)
- default
字段的默认值，可以是一个值，也可以是一个可调用对象，函数之类的
如果是可调用对象 ，每次在新对象创建的时候被调用
- help_text
额外的帮助信息，相当于注释
- primary_key
如果不设置primary_key，django会自动添加一个IntergerField来当主键
id = models.AutoField(primary_key=True)
如果设置primary_key=True，就会设置该字段为主键
主键是只读的，如果修改了主键再保存，将会创建一条新的数据
from django.db import models class Fruit(models.Model): name = models.CharField(max_length=100, primary_key=True) >>> fruit = Fruit.objects.create(name='Apple') >>> fruit.name = 'Pear' >>> fruit.save() >>> Fruit.objects.values_list('name', flat=True) <QuerySet ['Apple', 'Pear']>
- unique
如果为True，该字段必须唯一
如果想让几个字段合起来唯一，可以
class AppVersion(models.Model): class Meta: unique_together = ('app', 'version_number')
在model类里创建 Meta类，还支持其它的一些选项
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加s verbose_name_plural
- verbose_name
用来展示该字段的名字，默认与字段名一致，会把下划线替换成空格
除了ForeignKey， ManyToManyField， OneToOneField字段外，每个field第一个参数都是verbose_name
其它选项
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 RegexValidator from 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'), ] )
2.4 关系字段
2.4.1 一对多
一对多，可以在多的一侧添加 ForeignKey字段，指向一的一侧
如果指定自己，和自己一对多关系
models.ForeignKey('self',on_delete=models.CASCADE).
如果指向一个还未创建的对象，可以用字段串名字
from django.db import models class Car(models.Model): manufacturer = models.ForeignKey('Manufacturer',on_delete=models.CASCADE) # ... class Manufacturer(models.Model): # ... pass
外键字段会实际在数据表中创建一个 【字段名 + “_id"】的列
- on_delete
用来控制 当foreign_key关联的对象被删除时，字段的处理
| 选项 | 含义 |
| CASCADE | 包含FOREING_key的这条数据也被删除 |
| PROTECT | 不允许删除 ，删除时会报错 |
| SET_NULL | 设置为NULL，需要 null=True |
| SET | 可以传一个可调用对象，来设置值 |
| SET_DEFAULT | 设置为默认值 ，需要有一个默认值 |
| DO_NOTHING |
什么也不做, 在mysql上这个选项和PROTECT是一样的。 但db_constraint=False时，就是真的DO_NOTHING |
- limit_choices_to
数据表单或 admin中选择时做限制
下面的相当 于限制User表中is_staff=True
staff_member = models.ForeignKey(User, on_delete=models.CASCADE, limit_choices_to={'is_staff': True},)
- related_name
关联的对象调用带foreign_key对象时的方法名
- relate_query_name
关联的对象字段筛选带forein_key对象的名字
# Declare the ForeignKey with related_query_name class Tag(models.Model): article = models.ForeignKey(Article, on_delete=models.CASCADE, related_name="tags", related_query_name="tag",) name = models.CharField(max_length=255) # That's now the name of the reverse filter Article.objects.filter(tag__name="important")
- to_field
外键使用的字段名，默认是关联对象的主键，指定时必须保证该字段在关联对象上是唯一的
- db_constraint
True or False
控制是否创建数据库约束，默认会创建，有外键约束时，关联对象删除时必须先把引用关联对象作为外键的数据先删除
多对多，一对一
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 10 class 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, m1 class BB(models.Model): code = models.CharField(max_length=12) m1 = models.ManyToManyField('self',symmetrical=True) # 可选字段有: bb, code, id, m1 class BB(models.Model): code = models.CharField(max_length=12) m1 = models.ManyToManyField('self',symmetrical=False) through=None, # 自定义第三张表时，使用字段用于指定关系表 through_fields=None, # 自定义第三张表时，使用字段用于指定关系表中那些字段做多对多关系表 from django.db import models class 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, # 默认创建第三张表时，数据库中表的名称
3. 操作数据库
下面的代码都基于以下的模型，类似于一个博客APP
from django.db import models class Blog(models.Model): name = models.CharField(max_length=100) tagline = models.TextField() def __str__(self): return self.name class Author(models.Model): name = models.CharField(max_length=200) email = models.EmailField() def __str__(self): return self.name class Entry(models.Model): blog = models.ForeignKey(Blog, on_delete=models.CASCADE) headline = models.CharField(max_length=255) body_text = models.TextField() pub_date = models.DateField() mod_date = models.DateField() authors = models.ManyToManyField(Author) number_of_comments = models.IntegerField() number_of_pingbacks = models.IntegerField() rating = models.IntegerField() def __str__(self): return self.headline
3.1 创建数据
可以用创建一个模型对象，并用save方法来保存
假设上面的模型定义在mysite/blog/models.py中，可以通过下面的命令进入django的交互命令窗口
# python manager.py shell >>> >>> from blog.models import Blog >>> b = Blog(name='Beatles Blog', tagline='All the latest Beatles news.') >>> b.save()
上面的代码会调用INSERT语句向数据库中添加数据
注意，保存数据，必须调用save方法，如果不调用save方法，数据就不会保存
3.2 更新数据
>>> b5.name = 'New name' >>> b5.save()
上面的会调用 UPDATE语句来更新数据，同样，必须调用save方法后才执行生效
更新外键字段就和更新一个正常的字段是一样的，直接把外键对象赋值给外键字段就可以了
>>> from blog.models import Blog, Entry >>> entry = Entry.objects.get(pk=1) >>> cheese_blog = Blog.objects.get(name="Cheddar Talk") >>> entry.blog = cheese_blog >>> entry.save()
更新多对多有一点不同，需要用add 方法来添加，下面的例子添加一个作者对象到记录中
>>> from blog.models import Author >>> joe = Author.objects.create(name="Joe") >>> entry.authors.add(joe)
下面的例子，创建多个作者，并添加到多对多的字段中去
>>> john = Author.objects.create(name="John") >>> paul = Author.objects.create(name="Paul") >>> george = Author.objects.create(name="George") >>> ringo = Author.objects.create(name="Ringo") >>> entry.authors.add(john, paul, george, ringo)
3.3 查询数据
3.3.1 QuerySet
从数据库中查询数据，必须通过Model的Manager拿到一个QuerySet对象，
QuerySet 代表一数据库中每一条数据的集合，可以有零个或多个过滤器，
过滤器筛选数据集合，相当于SQL语句中的WHERE或LIMIT
而一个QeuerySet就相当于一个SELECT语句
通过Model的Manager拿到QuerySet, 每一个Model肯定有一个Manager，默认的话叫objects
可以直接通过模型类访问，注意不能通过对象访问
>>> Blog.objects <django.db.models.manager.Manager object at ...> >>> b = Blog(name='Foo', tagline='Bar') >>> b.objects Traceback: ... AttributeError: "Manager isn't accessible via Blog instances."
也可以按照下面的代码手动指定 Manager名字
from django.db import models class Person(models.Model): # Add manager with another name people = models.Manager()
3.3.2 查询全部
all方法可以获得一个包含数据表中全部的QuerySet对象
>>> all_entries = Entry.objects.all()
3.3.3 筛选查询
filter 返回匹配的查找
exclude 返回不匹配的查找
如果使用filter查找2006年的记录，如下
Entry.objects.filter(pub_date__year=2006)
也等价于下面的
Entry.objects.all().filter(pub_date__year=2006)
由于每一次查询返回的都是QuerySet对象，所以可以像下面这样链式筛选
>>> Entry.objects.filter( ... headline__startswith='What' ... ).exclude( ... pub_date__gte=datetime.date.today() ... ).filter( ... pub_date__gte=datetime.date(2005, 1, 30) ... )
QuerySet可以保存起来再使用，因为每一个QuerySet对象会根据筛选条件不同而不同
>>> q1 = Entry.objects.filter(headline__startswith="What") >>> q2 = q1.exclude(pub_date__gte=datetime.date.today()) >>> q3 = q1.filter(pub_date__gte=datetime.date.today())
QuerySet是懒加载的，直到你查询他们时，才会真正的去数据库中查询
>>> q = Entry.objects.filter(headline__startswith="What") >>> q = q.filter(pub_date__lte=datetime.date.today()) >>> q = q.exclude(body_text__icontains="food") >>> print(q)
只有最后的print(q)， 才执行了数据库的查询
3.3.4 获取单个对象
当你知道 ，只有一个对象能匹配上你的查询时，可以使用get方法直接拿到这个数据对象
可以像filter一样查询使用任意的查询条件
>>> one_entry = Entry.objects.get(pk=1)
如果一个数据也没有匹配，报异常DoesNotExist
如果匹配了不止一个数据，报异常MultipleObjectsReturned
3.3.5 限制数量
QuerySet类似一个列表对象，可以用切片的方法，限制查询的数量
这类似于SQL中的LIMIT和OFFSET
#LIMIT 5 >>> Entry.objects.all()[:5]
# OFFSET 5 LIMIT 5 >>> Entry.objects.all()[5:10]
注意，负数切片是不支持的，如Entry.objects.all()[-1]
如果使用了步长，注意就不能进一步的查询或排序了，
因为这样很混乱
#这个查询会立即返回每隔一条的数据 #不能再进行筛选了 >>> Entry.objects.all()[:10:2]
如果想返回单个对象，可以使用索引
>>> Entry.objects.order_by('headline')[0]
也可以
>>> Entry.objects.order_by('headline')[0:1].get()
也可以
>>> Entry.objects.order_by('headline').first()
3.3.6 字段查询
字段查询的一般格式是 【字段名__筛选类型=value】例如
>>> Entry.objects.filter(pub_date__lte='2006-01-01')
字段名必须是model中定义的字段，另外如果有外键，还可以有一个 外键字段名_id 的字段可以用来筛选
Entry.objects.filter(blog_id=4)
常用的筛选类型
| 筛选类型 | 功能 | 示例 | 等价SQL |
| exact |
严格匹配，可以用None来匹配NULL |
Entry.objects.get(id__exact=14)
Entry.objects.get(id__exact=None)
|
SELECT ... WHERE name ILIKE 'beatles blog';
SELECT ... WHERE name IS NULL;
|
| contains | 区分大小写的模糊匹配 |
Entry.objects.get(headline__contains='Lennon') |
SELECT ... WHERE headline LIKE '%Lennon%'; |
| icontains | 不分大小写的模糊匹配 |
Entry.objects.get(headline__icontains='Lennon') |
SELECT ... WHERE headline ILIKE '%Lennon%'; |
| in |
是否在一个序列中，可以是列表 元组，queryset
|
Entry.objects.filter(id__in=[1, 3, 4]) Entry.objects.filter(headline__in='abc') inner_qs = Blog.objects.filter(name__contains='Ch').values('name') entries = Entry.objects.filter(blog__name__in=inner_qs) |
SELECT ... WHERE id IN (1, 3, 4); SELECT ... WHERE headline IN ('a', 'b', 'c'); SELECT ... WHERE blog.name IN (SELECT name FROM ... WHERE NAME LIKE '%Ch%') |
| gt | 大于 |
Entry.objects.filter(id__gt=4) |
SELECT ... WHERE id > 4; |
| gte | 大于等于 |
Entry.objects.filter(id__gte=4) |
SELECT ... WHERE id >= 4; |
| lt | 小于 |
Entry.objects.filter(id__lt=4) |
SELECT ... WHERE id < 4; |
| lte | 小于等于 |
Entry.objects.filter(id__lte=4) |
SELECT ... WHERE id <= 4; |
| startswith | 大小写敏感，匹配以什么开始 |
Entry.objects.filter(headline__startswith='Lennon') |
SELECT ... WHERE headline LIKE 'Lennon%'; |
| istartswith | 不区分大小开，匹配以什么开始 |
Entry.objects.filter(headline__istartswith='Lennon') |
SELECT ... WHERE headline ILIKE 'Lennon%'; |
| endswith | 区分大小写，匹配以什么结尾 |
Entry.objects.filter(headline__endswith='Lennon') |
SELECT ... WHERE headline LIKE '%Lennon'; |
| iednswith | 不区分大小写，匹配以什么结尾 |
Entry.objects.filter(headline__iendswith='Lennon') |
SELECT ... WHERE headline ILIKE '%Lennon' |
| range | 匹配一个范围 |
import datetime start_date = datetime.date(2005, 1, 1) end_date = datetime.date(2005, 3, 31) Entry.objects.filter(pub_date__range=(start_date, end_date)) |
SELECT ... WHERE pub_date BETWEEN '2005-01-01' and '2005-03-31';
|
| isnull | 匹配NULL字段，可以用True或False |
Entry.objects.filter(pub_date__isnull=True) |
SELECT ... WHERE pub_date IS NULL; |
| regex | 匹配大小写的正则表达式 |
Entry.objects.get(title__regex=r'^(An?|The) +') |
SELECT ... WHERE title REGEXP BINARY '^(An?|The) +'; -- MySQL |
| iregex | 不分区大小写的正则表达式 |
Entry.objects.get(title__iregex=r'^(an?|the) +') |
SELECT ... WHERE title REGEXP '^(an?|the) +'; -- MySQL |
| date | 日期筛选 |
Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))
|
每个数据库上的实现方法都不一样，所以没有等价的SQL代码 |
注意，mysql的嵌套查询效率很低，不要过多使用，可以用下面的方法避免嵌套查询
values = Blog.objects.filter(
name__contains='Cheddar').values_list('pk', flat=True)
entries = Entry.objects.filter(blog__in=list(values))
3.3.7 跨关系查找
跨关系查找就相当于SQL里面的JOIN，联表查询，跨表查询
django提供了一套强大直观的方法，在幕后自动为我们处理相关的SQL语句
跨关系的时候，只需要把相关的字段，后面加上两个下划线，就可以直接跨到另一张表，引用它的相关字段了
无论多少表相关联，只要使用双下划线就都可以跨越
比如下面的就是查询所有Blog name字段是“Beatles Blog”的Entry对象
>>> Entry.objects.filter(blog__name='Beatles Blog')
同样可以反向引用，返向引用关联表，用关联表的名字全部转小写后当作字段名
比如查询Entry headline包含Lennon 的Blog对象
>>> Blog.objects.filter(entry__headline__contains='Lennon')
3.3.8 基本操作
# 增 # # models.Tb1.objects.create(c1='xx', c2='oo') 增加一条数据，可以接受字典类型数据 **kwargs # obj = models.Tb1(c1='xx', c2='oo') # obj.save() # 查 # # models.Tb1.objects.get(id=123) # 获取单条数据，不存在则报错（不建议） # models.Tb1.objects.all() # 获取全部 # models.Tb1.objects.filter(name='seven') # 获取指定条件的数据 # models.Tb1.objects.exclude(name='seven') # 获取指定条件的数据 # 删 # # models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据 # 改 # models.Tb1.objects.filter(name='seven').update(gender='0') # 将指定条件的数据更新，均支持 **kwargs # obj = models.Tb1.objects.get(id=1) # obj.c1 = '111' # obj.save() # 修改单条数据 基本操作
3.3.9 进阶操作
# 获取个数 # # models.Tb1.objects.filter(name='seven').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的值 # in # # models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据 # models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in # isnull # Entry.objects.filter(pub_date__isnull=True) # contains # # models.Tb1.objects.filter(name__contains="ven") # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感 # models.Tb1.objects.exclude(name__icontains="ven") # range # # models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and # 其他类似 # # startswith，istartswith, endswith, iendswith, # order by # # models.Tb1.objects.filter(name='seven').order_by('id') # asc # models.Tb1.objects.filter(name='seven').order_by('-id') # desc # group by # # from django.db.models import Count, Min, Max, Sum # models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num')) # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id" # limit 、offset # # models.Tb1.objects.all()[10:20] # regex正则匹配，iregex 不区分大小写 # # Entry.objects.get(title__regex=r'^(An?|The) +') # Entry.objects.get(title__iregex=r'^(an?|the) +') # date # # Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1)) # Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1)) # year # # Entry.objects.filter(pub_date__year=2005) # Entry.objects.filter(pub_date__year__gte=2005) # month # # Entry.objects.filter(pub_date__month=12) # Entry.objects.filter(pub_date__month__gte=6) # day # # Entry.objects.filter(pub_date__day=3) # Entry.objects.filter(pub_date__day__gte=3) # week_day # # Entry.objects.filter(pub_date__week_day=2) # Entry.objects.filter(pub_date__week_day__gte=2) # hour # # Event.objects.filter(timestamp__hour=23) # Event.objects.filter(time__hour=5) # Event.objects.filter(timestamp__hour__gte=12) # minute # # Event.objects.filter(timestamp__minute=29) # Event.objects.filter(time__minute=46) # Event.objects.filter(timestamp__minute__gte=29) # second # # Event.objects.filter(timestamp__second=31) # Event.objects.filter(time__second=2) # Event.objects.filter(timestamp__second__gte=31) 进阶操作
3.3.10 其它操作
# 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']) # F # # from django.db.models import F # models.Tb1.objects.update(num=F('num')+1) # Q # # 方式一： # Q(nid__gt=10) # Q(nid=8) | Q(nid__gt=10) # Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root') # 方式二： # 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) # 执行原生SQL # # from django.db import connection, connections # cursor = connection.cursor() # cursor = connections['default'].cursor() # cursor.execute("""SELECT * from auth_user where id = %s""", [1]) # row = cursor.fetchone() 高级操作
django中Q()函数的介绍 如果你需要进行复杂的查询（比如or条件），你可以使用Q对象。 Q对象是用来封装查询参数的，比如，它可以仅仅用来封装单独一个like查询： from django.db.models import Q Q(question__startswith='What') Q函数可以通过逻辑符号连接 Q对象可以和&、|这两个符号一起来使用，即and和or。下面这个例子就用or将两个查询组合在了一起： Q(question__startswith='Who') | Q(question__startswith='What') 相当于以下sql语句： WHERE question LIKE 'Who%' OR question LIKE 'What%' 另外，还可以使用非符号~，比如： Q(question__startswith='Who') | ~Q(pub_date__year=2005) Q函数用于数据库查询 以上介绍了Q的组合方法，那么怎么把它应用到数据库的查询呢？一般而言，可以把它们放到filter(),get()或者exclude()里面，比如： Poll.objects().filter(Q(question__startswith='Who') | ~Q(pub_date__year=2005)) Q函数和关键字参数混合使用 另外，Q对象还可以和关键字参数一起使用，不过Q一定要放在前面，以下是正确例子： Poll.objects.get( Q(question__startswith='Who'), Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)) ) 相当于sql查询语句如下： SELECT * from polls WHERE question LIKE 'Who%' AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06') 关键字参数放在前面是错误的用法！！如下是错误的！ # 错误用法 Poll.objects.get( question__startswith='Who', Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)) ) 我的实践 我喜欢这样来用Q对象。先在外面将条件组合好，然后再传入filter()、get()或者exclude()里面，代码片段如下： from django.db.models import Q my_filter = Q() my_filter = my_filter | Q(id=1) my_filter = my_filter | Q(name="lipengfei") result = People.objects.filter(my_filter)
浙公网安备 33010602011771号