Django 二——models（admin、ORM），一对一、一对多、多对多操作，all、values、value_list的对比
内容概要
1.关系对象映射ORM
2.admin的配置（选修）
3、all（）、values（）、value_list（）的对比
4、数据库操作（一对一、一对多、多对多）
5、HttpResponse和render的对比
1.关系对象映射ORM
一、用于实现面向对象编程语言里不同类型系统的数据之间的转换，换言之，就是用面向对象的方式去操作数据库的创建表以及增删改查等操作。
优点： 1 ORM使得我们的通用数据库交互变得简单易行，而且完全不用考虑该死的SQL语句。快速开发，由此而来。
2 可以避免一些新手程序猿写sql语句带来的性能问题。
缺点：1 性能有所牺牲，不过现在的各种ORM框架都在尝试各种方法，比如缓存，延迟加载登来减轻这个问题。效果很显著。
2 对于个别复杂查询，ORM仍然力不从心，为了解决这个问题，ORM一般也支持写raw sql。
3 通过QuerySet的query属性查询对应操作的sql语句
二、表(模型)的创建：
（1）、创建类，一个类指代一张表
（2）、创建字段，字段类型、长度、显示名称
一对一
一对多（外键）
多对多
（3）、生成同步数据库的脚本：python manage.py makemigrations
同步数据库: python manage.py migrate
例：
from django.db import models class Publisher(models.Model):
name = models.CharField(max_length=30, verbose_name="名称")
address = models.CharField("地址", max_length=50)
city = models.CharField('城市',max_length=60)
state_province = models.CharField(max_length=30)
country = models.CharField(max_length=50)
website = models.URLField() class Meta:
verbose_name = '出版商'
verbose_name_plural = verbose_name def __str__(self):
return self.name class Author(models.Model):
name = models.CharField(max_length=30)
def __str__(self):
return self.name class AuthorDetail(models.Model):
sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),))
email = models.EmailField()
address = models.CharField(max_length=50)
birthday = models.DateField()
author = models.OneToOneField(Author) class Book(models.Model):
title = models.CharField(max_length=100)
authors = models.ManyToManyField(Author)
publisher = models.ForeignKey(Publisher)
publication_date = models.DateField()
price=models.DecimalField(max_digits=5,decimal_places=2,default=10)
def __str__(self):
return self.title
三、模型常用的字段类型参数：
<1> CharField
#字符串字段, 用于较短的字符串.
#CharField 要求必须有一个参数 maxlength, 用于从数据库层和Django校验层限制该字段所允许的最大字符数. <2> IntegerField
#用于保存一个整数.
等等
四、Field重要参数
<1> null ： 数据库中字段是否可以为空
<2> blank： django的 Admin 中添加数据时是否可允许空值
<3> default：设定缺省值
等等
五、表的操作(增删改查)：
5.1、单表操作
--------基本操作：增删改查
1、增(create , save)
from app01.models import *
#create方式一: Author.objects.create(name='Alvin')
#create方式二: Author.objects.create(**{"name":"alex"})
#save方式一: author=Author(name="alvin")
author.save()
#save方式二: author=Author()
author.name="alvin"
author.save()
2、删（delete）
Book.objects.filter(id=1).delete()
(3, {'app01.Book_authors': 2, 'app01.Book': 1})
3、改（update和save）
#---------------- update方法直接设定对应属性----------------
models.Book.objects.filter(id=3).update(title="PHP")
#--------------- save方法会将所有属性重新设定一遍,效率低-----------
obj=models.Book.objects.filter(id=3)[0]
obj.title="Python"
obj.save()
4、查（filter，value等)
查询相关API：
# <1>filter(**kwargs): 它包含了与所给筛选条件相匹配的对象
# <2>all(): 查询所有结果
# <3>get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
#-----------下面的方法都是对查询的结果再进行处理:比如 objects.filter.values()--------
# <4>values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列 model的实例化对象，而是一个可迭代的字典序列
# <5>exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象
# <6>order_by(*field): 对查询结果排序
# <7>reverse(): 对查询结果反向排序
# <8>distinct(): 从返回结果中剔除重复纪录
惰性机制：
所谓惰性机制：Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet（查询结果集对象），它并不会马上执行sql，而是当调用QuerySet的时候才执行。
QuerySet特点：
<1> 可迭代的
<2> 可切片
--------进阶操作（双下划线）：大于、小于、in、contains、range、等
# 获取个数
#
# 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) 进阶操作
--------其他操作：F、Q、原生SQL
# 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() 其他操作
5.2、联表操作（利用双下划线和 _set 将表之间的操作连接起来）：
一对一
一对多 见博客第4点、
多对多 时见 http://www.cnblogs.com/tangtingmary/p/7994148.html 第12点。
2.admin的配置（选修）
admin是django强大功能之一，它能共从数据库中读取数据，呈现在页面中，进行管理。默认情况下，它的功能已经非常强大，如果你不需要复杂的功能，它已经够用，但是有时候，一些特殊的功能还需要定制，比如搜索功能，下面这一系列文章就逐步深入介绍如何定制适合自己的admin应用。
步骤：
1.在models中建几张表（类）
生成同步数据库的脚本：python manage.py makemigrations
同步数据库: python manage.py migrate
注意：在开发过程中，数据库同步误操作之后，难免会遇到后面不能同步成功的情况，解决这个问题的一个简单粗暴方法是把migrations目录下
的脚本（除__init__.py之外）全部删掉，再把数据库删掉之后创建一个新的数据库，数据库同步操作再重新做一遍。
2.创建超级管理员：python manage.py createsuperuser，设置好用户名和密码后便可登录http://127.0.0.1:8080/admin/啦！
3.在app01的admin.py中进行配置
一 认识ModelAdmin
管理界面的定制类，如需扩展特定的model界面需从该类继承。
二 注册medel类到admin的两种方式：
<1> 使用register的方法
|
1
|
admin.site.register(Book,MyAdmin) |
<2> 使用register的装饰器
|
1
|
@admin.register(Book) |
三 掌握一些常用的设置技巧
- list_display: 指定要显示的字段
- search_fields: 指定搜索的字段
- list_filter: 指定列表过滤器
- ordering： 指定排序字段
实例：
from django.contrib import admin
from app01.models import * #导入 # Register your models here. admin.site.register(Author)#该语句用来注册
admin.site.register(Publisher)#该语句用来注册 class MyAdmin(admin.ModelAdmin):
list_display = ("title","price","publisher")#定制显示哪些字段
search_fields = ("title", "publisher")#搜索插件，可根据title和publisher来搜索
list_filter = ("publisher",)#过滤器
ordering = ("price",)#排序
# fieldsets = [
# (None, {'fields': ['title']}),
# ('price information', {'fields': ['price', "publisher"], 'classes': ['collapse']}),
# ] admin.site.register(Book,MyAdmin)#该语句用来注册，且将MyAdmin与Book绑定
3、all（）、values（）、value_list（）的对比
一对多操作：
获取所有的学生--------获取DB数据
class Classes(models.Model):
caption = models.CharField(max_length=32) class Student(models.Model):
name = models.CharField(max_length=32)
email = models.CharField(max_length=32,null=True)
cls = models.ForeignKey('Classes')
原理讲解：
.all()
result = models.Student.object.all()
# QuerySet类型, select * from ....
# [obj,obj,obj,]，Django内部有一个模块，可以转换
# obj.name, obj.email, obj.cls_id, obj.cls.id, obj.cls.caption
.all().values（）
result = models.Student.object.all().values('id','name','email', 'cls_id', 'cls__id', 'cls__caption')
# QuerySet, select id.. from ...
# list(result) -> QuerySet -> list， json.dumps()
# [ {'id': 1, 'name': ...,},{'id': 1, 'name': ...,},{'id': 1, 'name': ...,},{'id': 1, 'name': ...,} ]
.all().value_list（）
result = models.Student.object.all().value_list('id','name','email', 'cls_id', 'cls__id', 'cls__caption')
# QuerySet, select id.. from ...
# list(result) -> QuerySet -> list， json.dumps()
# [ (1,'root'..),(1,'root'..),(1,'root'..),(1,'root'..),(1,'root'..) ]
# PS: QuerySet,无法直接使用json.dumps()序列化
# QuerySet
- Django内部有一个模块，可以转换
- values, value_list, 转换成 list(result)， json.dumps
获取数据：三种形式
请求数据：form(url)，ajax
all（）、values（）、value_list（）-------------------在模版语言显示数据(URL,Form表单的形式）
def index(request):
result = models.Student.object.all()
return render(request, 'index.html', {'reuslt': result}) {% for item in result%}
{{item.id}} - {{item.name}} - {{item.cls.id}} - {{item.cls.caption}}
{% endfor %}
def index(request):
result = models.Student.object.all().values('id','name','email', 'cls_id', 'cls__id', 'cls__caption')
# [ {'id': 1, 'name': ...,},{'id': 1, 'name': ...,},{'id': 1, 'name': ...,},{'id': 1, 'name': ...,} ]
return render(request, 'index.html', {'reuslt': result}) {% for item in result%}
{{item.id}} - {{item.name}} - {{item.cls__id}} - {{item.cls__caption}}
{% endfor %}
def index(request):
result = models.Student.object.all().value_list('id','name','email', 'cls_id', 'cls__id', 'cls__caption')
# QuerySet, select id.. from ...
# list(result) -> QuerySet -> list， json.dumps()
# [ (1,'root'..),(1,'root'..),(1,'root'..),(1,'root'..),(1,'root'..) ]
return render(request, 'index.html', {'reuslt': result}) {% for item in result%}
{{item.0}} - {{item.1}} - {{item.4}} - {{item.5}}
{% endfor %}
- Ajax请求
a.
$(function(){
$.ajax...
}) b.
def index(request):
result = models.Student.object.all()
# Django内部序列化工具
result = Django内部序列化工具 return HttpResponse(result) def index(request):
result = models.Student.object.all().values('id','name','email', 'cls_id', 'cls__id', 'cls__caption')
result = list(result)
result_str = json.dumps(result) return HttpResponse(result_str) def index(request):
result = models.Student.object.all().value_list('id','name','email', 'cls_id', 'cls__id', 'cls__caption')
result = list(result)
result_str = json.dumps(result) return HttpResponse(result_str) c.
$.each(function(){
# 构建html标签
# 将标签添加到HTML指定位置 })
4、数据库操作（一对一、一对多、多对多）
- 单表操作
- all
- filter （过滤）内部也可以放字典
models.tb.objects.filter(id=123) dic = {'id': 123, 'age__gt': 3}
models.tb.objects.filter(**dic)
- count
- order_by
...
- 一对多
1.（ForeignKey时，默认和主键id进行关联，也可以自定义nid（必须时唯一的unique=True）进行关联）
如：models.ForeignKey("Province", to_filed='nid')自定义和Province的nid进行关联
省
# id name
1 河北
2 广东
3 山东
class Province(models.Model):
name = models.CharField(max_length=32,)
# nid = models.Intergar(unique=True) # 唯一 市 省
# id name pro
1 东莞 2
2 深圳 2
3 惠州 2
4 河源 2
5 泰安 3
6 青岛 3
7 济南 3
8 张家口 1
9 邢台 1
class City(models.Model):
name = models.CharField(max_length=32)
pro = models.ForeignKey("Province", to_filed='id')（外键列，在数据库创建时的名称，自动会是pro_id，即【列名_id】) ---------------------------------------------------------------------
1、 正向查找（基于市查省份表，foreignkey在city里） （_ _id）
result = models.City.objects.all()
result[0].pro.name 跨表查询 models.City.objects.all().values('id','name','pro_id','pro__id','pro__name') 内部为字典#'pro__id','pro__name'是关联表里面的id和name
models.City.objects.all().values_list('id','name','pro_id','pro__id','pro__name') 内部为元祖 2、反向查找 （_set）
result = models.Province.objects.values('id','name', 'city__name') result = models.Province.objects.all()
result[0] # 获取河北
result[0].city_set.all() # 获取河北下的所有市 张家口 、邢台 for pro in result:
a1 = pro.id
a2 = pro.name
a3 = pro.city_set.all()
print(a1,a2,a3)
=====> 多对多即使基于一对多来构造
-多对多（自己创建关系表或Django默认帮我们创建）
class Book(models.Model):
name =models.CharField(max_length=32) class Author(models.Model):
name = models.CharField(max_length=32)
m = models.ManyToManyField('Book')
1.自己创建第三张表（后续操作方便）： class Book(models.Model):
name = .. class Author(models.Model):
name = .. class A_to_B(models.Model): #这种方式就不能使用Django自带的clear、remove等方法
bid = ForeignKey(Book)
aid = ForeignKey(Author)
====> 所有操作：化简为 单表操作 和 一对多操作 2.默认生成第三张表
只能间接对第三张表进行操作（因为没有第三张表的类） # 正向查找
# obj,人，金鑫
# obj = models.Author.objects.get(id=1)
#
# # 金鑫所有的著作全部获取到
# obj.m.all() # 反向查找
# 金品买
# obj = models.Book.objects.get(id=1)
# # 金鑫，吴超
# obj.author_set.all()
# 10
# author_list = models.Author.objects.all()
# for author in author_list:
# print(author.name,author.m.all()) # author_list = models.Author.objects.values('id','name','m', "m__name")
# for item in author_list:
# print(item['id'],item['name'],'书籍ID:',item['m'],item['m__name']) # 添加 # obj = models.Author.objects.get(id=1)
# 第三张表中增加一个对应关系
# 增加
# obj.m.add(5)
# obj.m.add(5,6)
# obj.m.add(*[4,5])
# 删除
# obj.m.remove(5)
# obj.m.remove(5,6)
# obj.m.remove(*[5,6])
# 清空
# obj.m.clear()
# 更新
# obj.m.set([1,2,3]) # 反向操作
# obj = models.Book.objects.get(id=1)
# obj.author_set.add(1)
# obj.author_set.add(1,2,3,4)
# ...
补充：
select_related 和 prefetch_related 函数优化查询
1. select_related()
对于一对一字段（OneToOneField）和外键字段（ForeignKey），可以使用select_related 来对QuerySet进行优化
作用和方法
在对QuerySet使用select_related()函数后，Django会获取相应外键对应的对象，从而在之后需要的时候不必再查询数据库了。以上例说明，如果我们需要打印数据库中的所有市及其所属省份，最直接的做法是：
>>> citys = City.objects.all()
>>> for c in citys:
... print c.province
... 这样会导致线性的SQL查询，如果对象数量n太多，每个对象中有k个外键字段的话，就会导致n*k+1次SQL查询。在本例中，因为有3个city对象就导致了4次SQL查询。 --------------------------------------------
如果我们使用select_related()函数：
>>> citys = City.objects.select_related().all()
>>> for c in citys:
... print c.province
... 就只有一次SQL查询，显然大大减少了SQL查询的次数： 这里我们可以看到，Django使用了INNER JOIN来获得省份的信息。
小结
1.select_related主要针一对一和多对一关系进行优化。
2.select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。
3.可以通过可变长参数指定需要select_related的字段名。也可以通过使用双下划线“__”连接字段名来实现指定的递归查询。没有指定的字段不会缓存，没有指定的深度不会缓存，如果要访问的话Django会再次进行SQL查询。
4.也可以通过depth参数指定递归的深度，Django会自动缓存指定深度内所有的字段。如果要访问指定深度外的字段，Django会再次进行SQL查询。
5.也接受无参数的调用，Django会尽可能深的递归查询所有的字段。但注意有Django递归的限制和性能的浪费。
6.Django >= 1.7，链式调用的select_related相当于使用可变长参数。Django < 1.7，链式调用会导致前边的select_related失效，只保留最后一个。
2. prefetch_related()
对于多对多字段（ManyToManyField）和一对多字段，可以使用prefetch_related()来进行优化。或许你会说，没有一个叫OneToManyField的东西啊。实际上 ，ForeignKey就是一个多对一的字段，而被ForeignKey关联的字段就是一对多字段了。
作用和方法
prefetch_related()和select_related()的设计目的很相似，都是为了减少SQL查询的数量，但是实现的方式不一样。后者是通过JOIN语句，在SQL查询内解决问题。但是对于多对多关系，使用SQL语句解决就显得有些不太明智，因为JOIN得到的表将会很长，会导致SQL语句运行时间的增加和内存占用的增加。若有n个对象，每个对象的多对多字段对应Mi条，就会生成Σ(n)Mi 行的结果表。prefetch_related()的解决方法是，分别查询每个表，然后用Python处理他们之间的关系。继续以上边的例子进行说明，如果我们要获得张三所有去过的城市，使用prefetch_related()应该是这么做：
最佳实践：
1.prefetch_related主要针一对多和多对多关系进行优化。
2.prefetch_related通过分别获取各个表的内容，然后用Python处理他们之间的关系来进行优化。
3.可以通过可变长参数指定需要select_related的字段名。指定方式和特征与select_related是相同的。
4.在Django >= 1.7可以通过Prefetch对象来实现复杂查询，但低版本的Django好像只能自己实现。
5.作为prefetch_related的参数，Prefetch对象和字符串可以混用。
6.prefetch_related的链式调用会将对应的prefetch添加进去，而非替换，似乎没有基于不同版本上区别。
7.可以通过传入None来清空之前的prefetch_related。
小结
- 因为select_related()总是在单次SQL查询中解决问题，而prefetch_related()会对每个相关表进行SQL查询，因此select_related()的效率通常比后者高。
- 鉴于第一条，尽可能的用select_related()解决问题。只有在select_related()不能解决问题的时候再去想prefetch_related()。
- 你可以在一个QuerySet中同时使用select_related()和prefetch_related()，从而减少SQL查询的次数。
- 只有prefetch_related()之前的select_related()是有效的，之后的将会被无视掉。
5、HttpResponse和render的对比
HttpResponse，传入的数据，直接返回给用户
render(request,'a.html', {'k':123})
1、找到html模版，open函数打开获取到内存
2、Django的模版引擎： html模版的内容 + 数据 => 渲染（替换） ===》 最终字符串
3、HttpResponse(最终字符串)
6、补充
a.
def index(request):
request.POST.get('k')
# checkbox--name相同,、select（多选时）可用getlist
request.POST.getlist('k')
b.模板语言里面（.html）调用方法不需要加括号
参考博客：
http://www.cnblogs.com/wupeiqi/articles/5246483.html
http://www.cnblogs.com/yuanchenqi/articles/6083427.html
Django 二——models（admin、ORM），一对一、一对多、多对多操作，all、values、value_list的对比的更多相关文章
- Django ORM 一对一,一对多,多对多, 添加,批量插入和查询
模型类 class Book(models.Model): nid = models.AutoField(primary_key=True) title = models.CharField(max_ ...
- JPA级联（一对一 一对多 多对多）注解【实际项目中摘取的】并非自己实际应用
下面把项目中的用户类中有个:一对一 一对多 多对多的注解对应关系列取出来用于学习 说明:项目运行正常 问题类:一对多.一对一.多对多 ============一对多 一方的设置 @One ...
- Python进阶----表与表之间的关系(一对一,一对多,多对多),增删改查操作
Python进阶----表与表之间的关系(一对一,一对多,多对多),增删改查操作,单表查询,多表查询 一丶表与表之间的关系 背景: 由于如果只使用一张表存储所有的数据,就会操作数 ...
- mybatis 一对一 一对多 多对多
一对一 一对多 多对多
- 【Django】--Models 和ORM以及admin配置
Models 数据库的配置 1 django默认支持sqlite,mysql, oracle,postgresql数据库 <1>sqlite django默认使用sqlite的数据库 ...
- Django之Models与ORM操作
一.models例子 from django.db import models class User(models.Model): """ 用户表 "" ...
- django之Models和ORM
ORM Object Relational Mapping,简称ORM,是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术. 通过使用描述对象和数据库之间映射的元数据,将程序中的对象自动持久 ...
- day 69-70 一对一 一对多 多对一联表查询
day 69 orm操作之表关系,多对多,多对一 多对一/一对多, 多对多{类中的定义方法} day69 1. 昨日内容回顾 1. 单表增删改查 2. 单表查询API 返回QuerySet对象的: 1 ...
- 使用NHibernate（7）-- 一对一 && 一对多 && 多对多
1, 一对一. 对于数据量比较大的时候,考虑查询的性能,肯能会把一个对象的属性分到两个表中存放:比如用户和用户资料,经常使用的一般是Id和用户名,用户资料(学校,籍贯等)是不经常被查询的,所以就会分成 ...
随机推荐
- 集合、迭代器、增强for循环、泛型
1集合 集合是java中提供的一种容器,可以用来存储多个数据. 数组的长度是固定的.集合的长度是可变的.集合中存储的元素必须是引用类型数据. 1.1ArrayList集合存储元素(复习) 例: pub ...
- dubbo rest返回值异常Incompatible types: declared root type
2018-08-28 17:26:02,208 [http-bio-9090-exec-1][][][][][] ERROR com.wjs.member.plugin.intercepter.Ser ...
- 【Unity3D】点击交互——简单工厂
实现一个很简单的点击小游戏,学习交互相关的内容,在不实时创建销毁的情况下,使用简单工厂创建.管理.回收.复用标记. 游戏概述:点击出现标记,两秒内自动消失 游戏展示: 1.1实现点击效果. 1.1.1 ...
- 常用的图片相关方法，读取，保存，压缩，缩放，旋转，drawable转化
import android.content.Context; import android.content.res.AssetManager; import android.content.res. ...
- SharePoint Online 缺少“将站点另存为模板”
之前文章行给出在SharePoint 2010 .SharePoint 2013 中将站点保存模板选项的文章.其实同样的问题出现在Microsoft Office 365的一部分SharePoint ...
- 简单案列完美搞定Mvc设计模式
一个小列子搞定Mvc模式,包括数据库以及如何提高用户体验度 1.首先来web.xml配置servlet的访问路径: <?xml version="1.0" encoding= ...
- python基础教程总结15——5 虚拟茶话会
聊天服务器: 服务器能接受来自不同用户的多个连接: 允许用户同时(并行)操作: 能解释命令,例如,say或者logout: 容易拓展 套接字和端口: 套接字是一种使用标准UNIX文件描述符(file ...
- groups - 显示用户所在的组
总览 (SYNOPSIS) groups [OPTION]... [USERNAME]... 描述 (DESCRIPTION) --help 显示此帮助, 然后退出 --version 显示版本信息, ...
- alibaba druid监控页面的使用配置
一.Maven中添加Durid连接池依赖 <!-- druid连接池 --> <dependency> <groupId>com.alibaba</group ...
- PAT (Basic Level) Practise （中文）- 1012. 数字分类 (20)
http://www.patest.cn/contests/pat-b-practise/1012 给定一系列正整数,请按要求对数字进行分类,并输出以下5个数字: A1 = 能被5整除的数字中所有偶数 ...