精华内容
下载资源
问答
  • 数据库中表与表之间存在着三种关系,也就是系统设计中三种实体关系。下面进行简单阐述。一对一创建表原则有两种: 唯一外键对应 在任意一方添加一个外键来描述对应关系。如下图所示: 或者 主键对应

    数据库中表与表之间的关系

    Hibernate框架基于ORM设计思想,它将关系型数据库中的表与我们Java中的类进行映射,一个对象就对应着表中的一条记录,而表中的字段对应着类中的属性。数据库中表与表之间存在着三种关系,也就是系统设计中的三种实体关系。下面我会进行简单阐述。

    一对一

    什么样的关系属于一对一呢?例如一个公司只能有一个注册地址,一个注册地址只能被一个公司注册。一对一关系的建表原则有两种:

    1. 唯一外键对应:在任意一方添加一个外键来描述对应关系。如下图所示:
      这里写图片描述
      或者
      这里写图片描述
    2. 主键对应:一方的主键作为另一方的主键。如下图所示:
      这里写图片描述

    实体类的设计:

    • 员工类:

      public class Employee {
      	// 其他属性...
      	private Archives archives;
      }
      
    • 档案类:

      public  class Archives {
      	// 其他属性...
      	private Employee employee;
      }
      

    一对多(多对一)

    什么样的关系属于一对多(或者多对一)呢?客户与订单之间的关系就是一对多(或者多对一)关系,还有,比方说:

    • 一个部门可以对应多个员工,但一个员工只能属于某一个部门;
    • 一个客户对应多个联系人,但一个联系人只能属于某一个客户。

    一对多(或者多对一)关系的建表原则:在多的一方添加外键来描述关联关系。如下图所示:
    这里写图片描述
    实体类的设计:

    • 客户类:

      public class Customer {
      	// 其他属性...
      	private Set<Order> orders;
      }
      
    • 订单类:

      public class Order {
      	// 其他属性...
      	private Customer c;
      }
      

    多对多

    什么样的关系属于多对多呢?学生与老师之间的关系就是多对多的关系,还有,比方说:

    • 一个学生可以选择多门课程,一门课程也可以被多个学生选择;
    • 一个用户可以选择多个角色,一个角色也可以被多个用户选择。

    多对多关系的建表原则:通过一张中间表来描述其对应关系。如下图所示:
    这里写图片描述
    实体类的设计:

    • 学生类

      public class Student {
      	// 其他属性...
      	private Set<Teacher> ts;
      }
      
    • 老师类

      public class Teacher {
      	// 其他属性...
      	private Set<Student> ss;
      }
      
    展开全文
  • ===========================实例一(onetoone)=======================1.models.py from django.db import models# 表之间数据一对一关系:一个账户对应一个联系人,反过来一个联系对应一个账户# 主表 从表# 账户...
    ===========================实例一(onetoone)=======================
    1.models.py

      from django.db import models


    # 表之间数据的一对一关系:一个账户对应一个联系人,反过来一个联系对应一个账户
    # 主表  从表
    # 账户表
    class Account(models.Model):
        
        aname = models.CharField(max_length=20)
        apwd = models.CharField(max_length=16)
        adate = models.DateTimeField(auto_now_add=True)
        
        class Meta:
            db_table = 'account'
            
        def __str__(self):
            return '{}'.format(self.aname)


    class Concat(models.Model):
        # 一个联系人要对应一个账户
        # OneToOneField() 一对一
        # 1.对应的数据模型类  on_delete 当主表中的数据被删除时,从表中的数据如何处理
        # on_delete=models.CASCADE 当主表中的数据删除时,从表数据也一并删除
        account = models.OneToOneField(Account, on_delete=models.CASCADE)
        # 当前表中的字段
        address = models.CharField(max_length=255)
        phone = models.CharField(max_length=11)
        
        class Meta:
            db_table = 'concat'
        
        def __str__(self):
            # self.account.aname 就是Account模型类对象的aname属性值
            return 'Concat:{}'.format(self.account.aname)
        
        

    2.views.py

    from django.shortcuts import render,HttpResponse


    from .models import Account,Concat
    # Create your views here.


    def add(request):
        
        # 先创建主表中的数据
        account = Account(aname='王老师', apwd='5235323', adate='2018-4-5')
        account.save()
        
        # account = Account.objects.get(id=4)
        # 将account和一个concat进行一对一的绑定
        # account参数必须是Account中的一条数据
        concat = Concat(account=account, address='zzz', phone='110')
        concat.save()
        
        return HttpResponse('成功')
        


    def select(request):
        # 1.通过从表查询主表中对应的数据
        concat = Concat.objects.get(id=3)
        # concat.account 这就是主表中的数据模型对象
        print(concat.account.aname, concat.account.apwd, concat.account.adate)
        
        # 2.通过主表中字段查询从表中的数据
        # 从表中的一对一字段名__主表字段___条件
        # account__aname__contains =
        concat = Concat.objects.get(account__aname__contains='小明')
        print(concat.address)
        print(concat.phone)
        print(concat.account.aname)
        print(concat.account.adate)
        
        return HttpResponse('成功......')


    def delete(request):
        
        # 1.删除从表数据,不会对主表造成影响
        # Concat.objects.get(id=2).delete()
        
        # 2.删除主表数据
        Account.objects.get(id=3).delete()



    ========================实例二(onetomany)=====================
    1.models.py

    from django.db import models

    # 数据库中数据一对多关系:例如 一个班级(主表)对应多个学生(从表)
    # 班级表(主表)
    class Classes(models.Model):
        
        cname = models.CharField(max_length=50)
        cnumber = models.IntegerField(null=False)
        
        class Meta:
            db_table = 'classes'


    class Students(models.Model):
        sname = models.CharField(max_length=20)
        sage = models.IntegerField(null=True)
        sex = models.BooleanField(choices=((True,'男'),(False,'女')),default=True)
        # 建立和班级的一对多关系
        # 通过设置外键建立一对多关系
        classes = models.ForeignKey(Classes,on_delete=models.CASCADE)
        
        class Meta:
            db_table = 'students'
        


    2.views.py

    from django.shortcuts import render,HttpResponse
    from .models import  Classes,Students

    def add(request):
        
        # 先创建classes数据
        c1 = Classes(cname='python7期',cnumber=22)
        c1.save()
        c2 = Classes(cname='python8期',cnumber=35)
        c2.save()
        c3 = Classes(cname='python9期',cnumber=30)
        c3.save()
        
        s1 = Students(classes=c1,sname='张三',sage=22,sex=1)
        s1.save()
        s1 = Students(classes=c1,sname='李四', sage=21, sex=0)
        s1.save()
        s1 = Students(classes=c1,sname='王五', sage=23, sex=1)
        s1.save()
        s1 = Students(classes=c2,sname='赵六', sage=24, sex=0)
        s1.save()
        s1 = Students(classes=c3,sname='赵四', sage=21, sex=1)
        s1.save()
        s1 = Students(classes=c3,sname='刘能', sage=23, sex=1)
        s1.save()
        s1 = Students(classes=c3,sname='谢大脚', sage=20, sex=0)
        s1.save()
        
        
        return HttpResponse('成功....')




    def select(request):
        
        #1.根据从表数据查询主表数据
        s = Students.objects.get(id=8)
        # 获取主表数据
        print(s.classes.cname)
        print(s.classes.cnumber)
        # 2.查询赵四所在的班级及班级人数
        s2 = Students.objects.get(sname='赵四')
        print(s2.classes.cname)
        print(s2.classes.cnumber)
        
        # 3.查询赵四所在班级的所有学员
        # res = Students.objects.filter(classes=s2.classes)
        # 获取班级对应的所有学员集合
        # classes.students_set 班级对应的学员集合
        res = s2.classes.students_set.all()
        for r in res:
            print(r.sname)
        


        # 根据班级名称查找所有的学员
        # c2 = Classes.objects.get(id=4)
        # Students.objects.filter(classes=c2)
        # 等同于下面这种写法
        c2 = Classes.objects.get(cname='python7期')
        res = c2.students_set.all()
        # c2.students_set.filter()
        # c2.students_set.get()
        for r in res:
            print(r.sname)
            
        return HttpResponse('///')
        
    def delete(request):
        # 直接删除主表中的数据
        # 从表中有数据的外键对应这个主表数据,会一并把从表中的数据进行删除(先删除从表数据,再删除主表数据)
        # Classes.objects.get(id=4).delete()
        
        # 删除从表中的数据,不会对主表数据造成影响
        Students.objects.get(sname='赵四').delete()
        return HttpResponse('//')

    =====================实例三(manytomany)=================
    1.models.py

    from django.db import models

    # 数据库中数据的多对多关系:一个表中的一条数据,对应着另外一个表中多条数据,反过来也是一样


    # 一篇文章可以在多个出版社出版,一个出版社可以出版多篇文章
    class Publication(models.Model):
        pname = models.CharField(max_length=50)
        paddress = models.CharField(max_length=100)
        
        class Meta:
            db_table = 'publication'
            
    class Article(models.Model):
        
        title = models.CharField(max_length=100)
        author = models.CharField(max_length=20)
        # 绑定多对多关系,ManyToManyField()
        publication = models.ManyToManyField(Publication)
        
        class Meta:
            db_table = 'article'
        

    # 用户评论表: 用户名/评论/时间/    文章表:文章标题/文章内容/作者

    2.views.py
    from django.shortcuts import render,HttpResponse

    from .models import Publication,Article

    def add(request):
        
        p1 = Publication(pname='新华社',paddress='北京')
        p1.save()
        p2 = Publication(pname='人民出版社', paddress='北京')
        p2.save()
        p3 = Publication(pname='清华出版社', paddress='北京')
        p3.save()
        p4 = Publication(pname='蓝翔出版社', paddress='山东')
        p4.save()
        
        a1 = Article(title='python教程',author='张三')
        a1.save()
        a2 = Article(title='java教程',author='李四')
        a2.save()
        a3 = Article(title='php教程',author='王五')
        a3.save()
        a4 = Article(title='HTML教程',author='赵四')
        a4.save()
        a5 = Article(title='Javascript教程',author='刘能')
        a5.save()
        
        # 如果是多对多关系,一定要将两张表中的数据保存成功后,在关联中间表
        # add使用add函数,中间表中添加记录


        # 如果是多对多关系,一定要将两张表中的数据保存成功后,在关联中间表
        # add使用add函数,中间表中添加记录


        # 如果是多对多关系,一定要将两张表中的数据保存成功后,在关联中间表
        # add使用add函数,中间表中添加记录
        
        # add添加对应的出版社
        a1.publication.add(p1,p2)
        a1.publication.add(p3)
        a2.publication.add(p2,p3,p4)
        a3.publication.add(p3,p4)
        a4.publication.add(p1,p4)
        a5.publication.add(p1,p2,p3,p4)
        
        return HttpResponse('成功........')
        


    def select(request):


        # 1.根据article对象,查询publication模型对象数据
        a1 = Article.objects.get(id=3)
        # 获取publication模型对象
        # 获取这篇文章对应的所有出版社
        res =  a1.publication.all()
        for r in res:
            # r就是一个出版,获取出版社出版的所有文章
            ares = r.article_set.all()
            # 循环遍历该出版社出版的每一篇文章
            for re in ares:
                print(r.pname,re.title )
                
        # 2.根据Pubilcation对象查询该出版社出版的article对象数据
        p1 = Publication.objects.get(id=3)
        res =  p1.article_set.all()
        for r in res:
            # 每一个r就是一篇文章
            print(r.title,r.author)
        
        return HttpResponse('///')




    def delete(request):

        a = Article.objects.get(id=4)
        res = a.publication.all()
        for r in res:
            # 解除数据之间的关联
            a.publication.remove(r)
        # 删除对应的数据
        a.delete()

        return HttpResponse('')












      











        
            


        











    展开全文
  • 数据库中表之间的关系有:1、一对多关系,即A表的一条记录对应B表的一条记录;2、多对多关系,即A表的一条记录,对应B表的多条记录,且A的主键作为B表的外键;3、一对一关系。本教程操作环境:windows10系统、mysql8...

    数据库中表之间的关系有:1、一对多关系,即A表的一条记录对应B表的一条记录;2、多对多关系,即A表的一条记录,对应B表的多条记录,且A的主键作为B表的外键;3、一对一关系。

    aae49eb04b352d609c87da6690f45ce6.png

    本教程操作环境:windows10系统、mysql8版、Dell G3电脑。

    表关系:可以在数据库图表中的表之间创建关系,以显示一个表中的列与另一个表中的列是如何相链接的。

    在一个关系型数据库中,利用关系可以避免多余的数据。例如,如果设计一个可以跟踪图书信息的数据库,您需要创建一个名为 titles 的表,它用来存储有关每本书的信息,例如书名、出版日期和出版社。您也可能保存有关出版社的信息,诸如出版社的电话、地址和邮政编码。如果您打算在 titles 表中保存所有这些信息,那么对于某出版社出版的每本书都会重复该出版社的电话号码。

    更好的方法是将有关出版社的信息在单独的表,publishers,中只保存一次。然后可以在 titles 表中放置一个引用出版社表中某项的指针。

    为了确保您的数据同步,可以实施 titles 和 publishers 之间的参照完整性。参照完整性关系可以帮助确保一个表中的信息与另一个表中的信息相匹配。例如,titles 表中的每个书名必须与 publishers 表中的一个特定出版社相关。如果在数据库中没有一个出版社的信息,那么该出版社的书名也不能添加到这个数据库中。

    表之间有三种关系。所创建关系的类型取决于相关列是如何定义的。一对多关系

    多对多关系

    一对一关系

    1.一对一

    Ø一对一是将数据表“垂直切分”,其实是不常见,或不常用的。也就是A表的一条记录对应B表的一条记录,为什么要这样的设计呢,不是增加了程度的复杂性吗,然而并不一定,举例说明:

    1)一个系统必然有 Employee(员工表)(包含字段:EmployeeId、姓名、性别、年龄、电话、地址等),每个员工都为一个用户,所以还有张User表(包含字段:UserId(关联 EmployeeId)、用户名、密码、角色等),这样你会发现,整合为一张表是否不太妥当?因为,User的记录只会在登录时用到,感觉有点违背三大范式中的“确保每列都和主键列直接关联,而不是间接关联”。

    2)还有种情况,这就要根据具体的业务来决定了。如果,当一张表的字段过于太多,而很多字段可能只有在某些情况下,才会使用到,这时也可以考虑使用一对一设计。

    Ø优点

    1.便于管理、可提高一定的查询速度

    2.减轻CPU的IO读写,提高存取效率。

    3.符合数据库设计的三大范式。

    4.符合关系性数据库的特性。

    Ø缺点

    1.增加一定的复杂程度,程序中的读写难度加大。

    2.一对多

    Ø一对多,是最常见的一种设计。就是A表的一条记录,对应B表的多条记录,且 A的主键作为B表的外键。这主要看以哪张表为中心,以上示例以A表为中心,就是一对多,如果以B表为中心,则是多对一。举几个例子:

    1.班级表 与 学生表,一个班级对应多个学生,或者多个学生对应一个班级。

    2.角色表 与 用户表,一个角色对应多个用户,或者多个用户对应一个角色。

    3.商品表 与 图片表,一个商品对应多张图片,或者多张图片对应一个商品。

    3.多对多

    Ø多对多,在数据库中也比较常见,可以理解为是一对多和多对一的组合。要实现多对多,一般都需要有一张中间表(也叫关联表),将两张表进行关联,形成多对多的形式。例如:

    1.老师表、班级表、科目表,中间表为:课程表

    1)SQL:

    --教师表

    CREATETABLE #Teacher(TeacherId int, Name nvarchar(20));

    INSERTINTO #Teacher VALUES(1, '张老师'),(2, '王老师');

    --班级表

    CREATETABLE #Class(ClassId int, Name nvarchar(20));

    INSERTINTO #Class VALUES(1, '一班'),(2, '二班');

    --课程表(关联表)

    CREATETABLE #Courses(CoursesId int IDENTITY(1, 1), TeacherId int, ClassId int, Name nvarchar(20));

    INSERTINTO #Courses VALUES(1, 1, '语文'),(1, 2, '语文');

    INSERTINTO #Courses VALUES(2, 1, '数学'),(2, 2, '英语');

    SELECTT1.TeacherId, T2.Name, T1.ClassId, T3.Name, T1.Name FROM #Courses AS T1, #Teacher AS T2, #Class AS T3

    WHERET1.TeacherId=T2.TeacherId AND T1.ClassId=T3.ClassId

    DROPTABLE #Teacher, #Class, #Courses;

    2)执行结果:

    05d9014e65ae219228e1bb9439e8d6fb.png

    展开全文
  • 1.在关系型数据库中表与表之间的关系主要有三种:(1)一对一,(2)一对多,(3)多对多 (1)一对一:两张表中的数据是一一对应的,例如--> 用户表user ------- 身份信息表 (2)一对多:一张表中的数据,在另...

    1.在关系型数据库中,表与表之间的关系主要有三种:(1)一对一,(2)一对多,(3)多对多

    (1)一对一:两张表中的数据是一一对应的,例如--> 用户表user ------- 身份信息表 

    (2)一对多:一张表中的数据,在另一张表中对应多条数据,例--> 英雄表hero ----- 技能表 

    (3)多对多:A表中的数据,在B表中对应多条数据。B表中的数据,在A表中对应多条数据。例-->老师表 ---- 学生表

    2.对于一对一而言,从某些层面上来讲吗,它是没有意义的,我们在设计数据库表时,将表设计成一对一的关系,往往是因为当前表中的字段太多。比如:当前表中一共有100个字段,我们可以将这100个字段拆分成5张表。

    我们在设计一对一这种表关系时,一般需要考虑两种因素:

    (1)数据库的查询性能:对一张表而言,不能有太多的字段。因为如果我们使用ORM映射的方式来查询数据库时,它会将所有的字段信息全部查出,这时,如果一张表的字段太多,会影响查询的性能。

      (2)  考虑业务因素:出于业务的角度,可能需要当前一张大表中的某些字段,需要独立出来,单独形成一张独立的表。这时可以考虑将表进行拆分。

    3.多对多的关系:

    在多对多的关系中,我们需要设计一张中间表,三张表才可以确定一条整体的数据。中间表大致分为两种:(1)只是有确定关联关系的作用,不存在具有业务意义的字段。(2)不仅仅有关联两张表的作用,还存在具有业务意义的字段。

    4.设计数据库表的步骤:

    (1)我们不应该将数据库的每一张表仅仅当做是数据表来处理,而是应该与我们项目中的实体类相对应,每一个实体类对应于数据库中的一张表。

    (2)我们首先需要规划出业务中的一个个业务对象,然后根据业务对象来设计数据库表。

    (3)思考对象与对象之间的业务依赖关系-->是一对一,一对多,还是多对多。那么表与表之间的关联是通过外键的形式来实现的。外键又分为逻辑外键,物理外键。对于物理外键,一般不建议使用。

    (4)整体设计完以后,最后对数据库表进行细化。例如:字段类型,字段的长度限制,是否为空......

            以上只是设计简单项目的数据库,但是对于存储海量数据的数据库而言,我们还需要思考一些其他的维度。例如:单表中的数据记录越多,对数据库性能的影响就会越大。如果单表的字段数量太多,那么就需要考虑对数据库进行垂直拆分,记录太多,那么就需要考虑对数据库进行水平拆分。

     

    5.设计数据库表时,对于是否需要设置物理外键的探讨:

    使用物理外键的好处:它的约束力比较强,可以保证数据的强一致性,但是会影响数据库的查询效率。不使用物理外键,对数据库而言,没有那么强的约束力,相对能提高数据的查询效率。普遍认为,不提倡使用物理外键。

    展开全文
  • 数据库表与表之间的关系

    千次阅读 2016-11-21 14:42:45
    表与表之间的关系 一对一关系 在这种关系,父表的每一条记录最多与子表的一条记录相关联,在实际工作,一对一关系使用的很少,因为存在一对一关系的两个表可以简单地合成一个表 一对多关系 这是最普通和...
  • 我先来跟大家探讨一下儿数据库表间建立关系的利敝: 利:如果你的关系建立的没有错误的话数据的参照完整性肯定能得到保证,不会出现数据不一致的情况。实现级连删除非常方便。省去了为保证参照完整性用代码保证级...
  • 关系型数据库表与表之间的关系

    千次阅读 2017-12-25 15:29:59
    定义:有两个,在第一个表中的某一行只第二个表中的一行相关,同时第二个表中的某一行,也只第一个表中的一行相关,我们称这两个为一对一关系。 例如: 第一张表: ID 姓名 国籍 ...
  • 一、一对多关系 定义一张部门员工 我们就会发现把所有数据存放于一张的弊端: 1.组织结构不清晰 ...那么我再来分析这张表数据之间的关系:多个用户对应一个部门,一个部门就对应了多个用户...
  • 一、一对一关系:定义:有两个,在第一个表中的某一行只第二个表中的一行相关,同时第二个表中的某一行,也只第一个表中的一行相关,我们称这两个为一对一关系。例如:第一张表:ID姓名国籍贡献1001王大锤...
  • 例:公司员工的关系,公司为一,公司员工为多,需要在多方建立外键指向一方的主键。 二、多对多的关系 例:商品订单的关系,一个商品可以属于多个订单,一个订单可以有多种商品。  用户和角色的关系,一个...
  • 表与表之间的关系 可以分成三类 一对一关系:一般情况下,一对一关系基本不用,当发现两张表是一对一的关系,就合成一张表,例如:人和身份证号 一对多关系:在表关系是最多的情况,也是最常见的,比如:部门和...
  • 2.1 多表之间的关系 1、一对一(了解): 如,人和身份证; 2、一对多(多对一): 如,部门和员工,一个部门有多个员工,一个员工只能对应一个部门; 3、多对多: 如,学生和课程,一门课程可以被多个学生...
  • 表与表之间的关系 说明 关系的维护 一对一 相对使用比较少。简历表, 公民表 护照表,人和身份证 1)特殊一对多,从表的外键设置为唯一,2)从表的主键又是外键 一对多 最常用的关系 部门和员工(一个部门多...
  • 数据库的学习,对于一个表的主键和外键认识是非常重要。 主键:在一个表中,能唯一表示一个事物(或者一条记录)字段,我们称之为主键 注意:  主键设置可以不只是用一个字段,也可以用若干个字段...
  • 数据库表之间关系与实体类对应

    千次阅读 2020-01-15 17:33:42
    如何在实体类体现一对多,多对多的关系 一对多: 在从表中添加主的实体类属性 在主表中添加从的实体类的集合属性 多对多: 在两个表中可添加另一个的实体类的集合属性 ...
  • NHibernate是一个O/RM框架在其应用会...没有Mapping配置文件NHibernate无法根据实体类生成数据库表,无法形成对象与数据库表的映射。实体类和数据库表是相互独立二者不知道对方存在,中间任何交互都是通过Map
  • 简述关系数据库中表与表的 3 种关系 一对一的关系:例如:一个人对应一个唯一的身份证号,即为一对一的关系。 一对多关系 :例如:一个班级对应多名学生,一个学生只能属于一个班级,即为一对多关系 多对多关系 ...
  • 表之间的关系:一对多,多对多,一对一,我们必须遵循数据完整性的参照完整性。 简单提及一下,数据完整性有:实体完整性,域完整性,参照完整性。 表与表之间的关联关系: 一对多: CustomerDaoImpl.java ...
  • 数据库表中字段之间的关系设置

    千次阅读 2008-03-13 18:57:00
    如果要设置表1与表2相对应的字段之间的关系,先的那个表的字段,只能是外键,只要不是与表自身建立关系。这就像C++的控件在排列时会发生的情况一样:最后,如果是按第一行与第二行的间距也排列其他行之间的...
  • 今天公司给了一个任务,某一个项目由于...表与表之间的约束关系(外键,check,default)一致; 2.有些表不想要就不要,可选。 3.而且效率要考虑,这个脚本以后常用。 (这里都是本地的测试数据) 软件: Sql...
  • 关系数据库中表与表的 3 种关系 1)一对一的关系 例如:一个人对应一个唯一的身份证号,即为一对一的关系。 一篇文章对应一个文章详情, 本来可以是一张表,拆分成2张表 2)一对多关系 例如:一个班级对应多名...
  • Oracle数据库用户、空间之间关系 先需要明白数据库的物理结构是由数据库的操作系统文件所决定,每一个Oracle数据库是由三种类型文件组成:数据文件、日志文件和控制文件。数据库的文件为数据库信息提供真正...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,218
精华内容 1,687
关键字:

数据库中表与表之间的关系