多对多关系表
数据库一对一、一对多、多对多关系
数据库⼀对⼀、⼀对多、多对多关系数据库⼀对⼀、⼀对多、多对多关系⼀、⾸先给出三种关系的实例⼀对⼀关系实例⼀个⼈对应⼀张⾝份证，⼀张⾝份证对应⼀个⼈⼀对多关系实例⼀个公司的部门拥有多个职员，⼀个职员只能够属于某个部门多对多实例⼀本图⽰可以拥有多个作者，⼀个作者可以写很多本书。
⼀对⼀关系⼀对多，是最常见的⼀种设计。
就是 A 表的⼀条记录，对应 B 表的多条记录，且 A 的主键作为 B 表的外键。
这主要看以哪张表为中⼼。
优点便于管理、可提⾼⼀定的查询速度减轻 CPU 的 IO 读写，提⾼存取效率。
符合数据库设计的三⼤范式。
符合关系性数据库的特性。
缺点增加⼀定的复杂程度，程序中的读写难度加⼤。
# 左表的⼀条记录唯⼀对应右表的⼀条记录，反之也⼀样# ⾝份证表create table iden(id int primary key auto_increment,name char(20) not null,iden_num char(18) not null unique);# 公民表create table civi(id int primary key auto_increment,name char(20) not null,civi_id int unique,foreign key(iden_id) references ident(iden_num) #外键的字段⼀定要保证uniqueon delete cascadeon update cascade);⼀对多关系⼀对多，是最常见的⼀种设计。
就是 A 表的⼀条记录，对应 B 表的多条记录，且 A 的主键作为 B 表的外键。
这主要看以哪张表为中⼼，我们把多对⼀和⼀对多统称为⼀对多关系，数据库中不存在多对⼀关系。
create table dep(id int primary key auto_increment,dep_name char(10),dep_comment char(60));create table emp(id int primary key auto_increment,name char(16),gender enum('male','female') not null default 'male',dep_id int,foreign key(dep_id) references dep(id)on update cascadeon delete cascade);多对多关系多对多，在数据库中也⽐较常见，可以理解为是⼀对多和多对⼀的组合。
数据库表关系模型解析6——多对多
数据库表关系模型解析6——多对多狼奔代码生成器是一款为程序员设计的前期开发辅助工具，是一个软件项目智能开发的平台，它可以自动生成页面及后台代码。
实践开发过程中，我们使用PowerDesigner设计数据库模型。
狼奔代码生成器就是读取PowerDesigner设计的数据库模型，分析其中的表与表之间的关系模型，分析其中的表和字段的说明信息中的关键字，自动生成不同的页面。
表与表之间的关系模型包括1.单表数据模型2.自连接数据模型3.一对一数据模型4.一对多数据模型5.一对多数据模型中的一张表是自连接6.多对多数据模型7.多对多数据模型中的一张表是自连接关键字包括1.查询2.状态3.上传4.工作流架构图数据访问层(DAL)数据实体Entity Framework业务实体和校验元数据业务逻辑层(BLL)业务处理工作流事务接口层(IBLL)服务契约展示层（App ）View （视图）Controller （控制器）Models （页面实体）对其他系统暴露服务Service （服务）公共组件安全组件日志记录异常捕获公共类库(Common)组件说明图表1项目组件说明图1)App——页面展示层采用MVC框架，使用Jquery脚本库，控件选用Easyui。
2)WcfHost——服务宿主(后期扩展)为对外的服务提供宿主，使用WCF技术，HTTPS通讯协议。
3)IBLL——业务接口层业务逻辑层的方法对外暴露的接口和服务契约。
4)BLL——业务逻辑层业务逻辑的操作，包括业务处理，事务，日志。
5)DAL——数据访问层数据库访问的操作，数据实体，业务实体，数据校验，使用Entity Framework。
6)Common——公共组件层整个应用程序使用的公共辅助方法。
7)WFActivitys——工作流活动层(后期扩展)定义了工作流需要的活动，使用微软WF技术。
8)WFDesigner——工作流设计器(后期扩展)可以让实施人员自由配置工作流的设计器，使用微软WPF技术。
数据库实体间一对多（多对一）、多对多关系处理
数据库实体间⼀对多（多对⼀）、多对多关系处理
数据库实体间有三种对应关系：⼀对⼀，⼀对多，多对多。
⼀对⼀关系⽰例：⼀个学⽣对应⼀个学⽣档案材料，或者每个⼈都有唯⼀的⾝份证编号。
⼀对多关系⽰例：⼀个学⽣只属于⼀个班，但是⼀个学院有多名学⽣。
多对多关系⽰例：⼀个学⽣可以选择多门课，⼀门课也有多名学⽣。
这三种关系在数据库中逻辑结构处理分析：
1.⼀对多关系处理：
我们以学⽣和班级之间的关系来说明⼀对多的关系处理⽅法。
假设现有基本表学⽣表（学号，姓名，……），班级表（班级号，备注信息，……）。
⽅法⼀：
新增⼀个关系表，⽤来表⽰学⽣与班级的属于关系，该关系表包含字段（学⽣号，班级号）。
通过学⽣号与班级号的对应关系表⽰学⽣属于的班级。
⽅法⼆：
在学⽣表中新增字段（班级号），该字段作为学⽣表的外键与班级表中的班级号关联。
每⼀个学⽣实体在班级号字段的值，表⽰该学⽣属于的班级。
⼩结：⼀般情况下，⼀对多关系采⽤⽅法⼆来处理。
⼀对多的两个实体间，在“多”的实体表中新增⼀个字段，该字段是“⼀”实体表的主键。
2.多对多关系处理：
在多对多关系中，我们要新增加⼀个关系表。
如在上⾯⽰例中，在学⽣表和课程表的基础上增加选课表来表⽰学⽣与课程之间的多对多关系。
在选课表中，必须含有的属性有学⽣号和课程号。
（学⽣号，课程号）这个属性集刚好也就是选课表的关键字。
1对1,1对多,多对多的逻辑关系
1对1,1对多,多对多的逻辑关系
摘要：
一、引言
1.逻辑关系的概念
2.逻辑关系的分类
二、1 对1 的逻辑关系
1.定义与特点
2.实例分析
三、1 对多的逻辑关系
1.定义与特点
2.实例分析
四、多对多的逻辑关系
1.定义与特点
2.实例分析
五、总结
1.逻辑关系在实际应用中的意义
2.逻辑关系对思维方式的影响
正文：
逻辑关系是我们在思考和分析问题时，对事物之间联系的一种表达方式。
在众多逻辑关系中，1 对1、1 对多和多对多是最基本的三种关系。
首先，我们来了解一下1 对1 的逻辑关系。
这是一种单一的、明确的关
系，例如：学生与课程之间就是1 对1 的关系，一个学生可以选择多门课程，但一门课程只能被一个学生选择。
其次，1 对多的逻辑关系是指一个对象可以与多个其他对象发生关系，例如：教师与课程之间的关系。
一个教师可以教授多门课程，而一门课程可以由多个教师来教授。
最后，多对多的逻辑关系是指多个对象之间可以相互关联，例如：学生选课关系。
一个学生可以选择多门课程，同样，一门课程也可以被多个学生选择。
这种关系较为复杂，需要通过建立中间表来解决数据冗余和查询困难的问题。
总之，1 对1、1 对多和多对多的逻辑关系在我们日常生活和工作中无处不在，它们有助于我们更好地理解事物之间的关系，从而进行有效沟通和高效工作。
图文详解laravel多对多关联模型
图⽂详解laravel多对多关联模型关联模型（多对多）多对多关系（抽象）例：⼀篇⽂章可能有多个关键词，⼀个关键词可能被多个⽂章使⽤。
关键词表：字段id主键字段keyword关键词⽂章与关键词的关系表：字段id主键----字段article_id⽂章id字段key_id关键词id创建迁移⽂件：php artisan make:migration create_keyword_tablephp artisan make:migration create_relation_table编写迁移⽂件的代码：执⾏迁移php artisan migrate创建填充器：php artisan make:seeder KeywordAndRelationTableSeeder编写填充器数据：字段id 主键<?phpnamespace Database\Seeders;use Illuminate\Database\Seeder;use DB;class KeywordAndRelationTableSeeder extends Seeder{/*** Run the database seeds.** @return void*/public function run(){//关键词数据DB::table('keyword') -> insert([['keyword' => '搞笑'],['keyword' => '⽂艺'],['keyword' => '正⽚'],['keyword' => '惊悚'],['keyword' => '娱乐'],['keyword' => '武术'],]);//关系表DB::table('relation') -> insert([['article_id' => rand(1,3),'keyword_id' => rand(1,6)],['article_id' => rand(1,3),'keyword_id' => rand(1,6)],['article_id' => rand(1,3),'keyword_id' => rand(1,6)],['article_id' => rand(1,3),'keyword_id' => rand(1,6)],]);}}执⾏填充器：php artisan db:seed --class=KeywordAndRelationTableSeeder案例：查询出每个⽂章（主）下全部的关键词（从）语法：return $this -> belongsToMany(被关联模型的元素空间路径, 多对多模型的关系表名, 关系表中当前模型中的关系键，关系表中被关联模型的关系键)上述语法提及到的关系键是指在关系表中的字段名。
数据库-一对一、一对多、多对一、多对多关系
数据库-⼀对⼀、⼀对多、多对⼀、多对多关系
⼀对多关系、多对⼀关系和⼀对⼀关系
1. ⾄少都有⼀侧是单个实体，所以记录之间的联系通过外键实现，让外键指向这个实体。
2. 实现这种关系时，要在“多”这⼀侧加⼊⼀个外键，指向“⼀”这⼀侧联接的记录。
多对多关系
1. 解决⽅法是添加第三个表，这个表称为关联表。
2. 多对多关系可以分解成原表和关联表之间的两个⼀对多关系
多对多关系例⼦
查询多对多关系要分成两步。
1. 若想知道某位学⽣选择了哪些课程，要先从学⽣和注册之间的⼀对多关系开始，获取这位学⽣在 registrations 表中的所有记录。
2. 然后再按照多到⼀的⽅向遍历课程和注册之间的⼀对多关系，找到这位学⽣在 registrations 表中各记录所对应的课程。
3. 同样，若想找到选择了某门课程的所有学⽣，你要先从课程表中开始，获取其在 registrations 表中的记录，再获取这些记录联接的学⽣。
⾃引⽤关系也是多对多的⼀种特殊情况
如果关系中的两侧都在同⼀个表中，这种关系称为⾃引⽤关系。
在关注中，关系的左侧是⽤户实体，可以称为“关注者”；关系的右侧也是⽤户实体，但这些是“被关注者”。
多对多关系表
数据库建表-- 一对多/多对一/一对一/多对多关系关联映射：一对多/多对一存在最普遍的映射关系，简单来讲就如球员与球队的关系；一对多：从球队角度来说一个球队拥有多个球员即为一对多多对一：从球员角度来说多个球员属于一个球队即为多对一数据表间一对多关系如下图：关联映射：一对一关系就如球队与球队所在地址之间的关系，一支球队仅有一个地址，而一个地址区也仅有一支球队。
数据表间一对一关系的表现有两种，一种是外键关联，一种是主键关联。
图示如下：一对一外键关联：一对一主键关联：要求两个表的主键必须完全一致，通过两个表的主键建立关联关系关联映射：多对多多对多关系也很常见，例如学生与选修课之间的关系，一个学生可以选择多门选修课，而每个选修课又可以被多名学生选择。
数据库中的多对多关联关系一般需采用中间表的方式处理，将多对多转化为两个一对多。
数据表间多对多关系如下图：----------------------------------------------------------------------------------------------------------前言：多对多关系至少需要3个表，我们把一个表叫做主表，一个叫做关系表，另外一个叫做字典表或者副表（字典表是纪录比较少，而且基本稳定的，例如：版块名称；副表是内容比较多，内容变化的，例如）。
按照数据库的增删查改操作，多对多关系的查找都可以用inner join或者select * from 主表where id in (select 主表id from 关系表)1，角色任命型特点：关系表两外键组合无重复纪录，关系表一般不需要时间字段和主键，有一个表是字典类型的表。
界面特点：显示主表，用checkbox或多选select设置多选关系。
例如：任命版主（用户表-关系表-版块名称表），角色权限控制等，用户是5个版块版主，只要关系表5行纪录就可以确立，关系表的两个外键具有联合主键性质。
数据库在一对一、一对多、多对多怎么设计表关系
数据库在⼀对⼀、⼀对多、多对多怎么设计表关系1、⼀对⼀可以两个实体设计在⼀个数据库中l例如设计⼀个夫妻表，⾥⾯放丈夫和妻⼦2、⼀对多可以建两张表，将⼀这⼀⽅的主键作为多那⼀⽅的外键，例如⼀个学⽣表可以加⼀个字段指向班级(班级与学⽣⼀对多的关系)3、多对多可以多加⼀张中间表，将另外两个表的主键放到这个表中（如教师和学⽣就是多对多的关系）关于外键的设置：⾸先，外键引⽤的那个列在主表中必须是主键列或者唯⼀列。
所以1：n的肯定把外键建⽴在n的那张表上。
1：1，⼀般要看谁是主表，谁是附属表，外键当然建⽴在附属表中。
n：m的情况，需要建⽴⼀个关系表，两个原表和其关系分别是1：n，1：m关于主外键及多表联系的进⼀步理解：主外键的存在是依托两个实体之间的关系⽽存在的；⽐如班级与学⽣的关系：⼀个班级可以有多个学⽣，并且⼀个学⽣只能属于⼀个班级，这就是⼀对多的关系；那么设计数据库的时候就应该在学⽣表内存放班级的ID作为外键，为什么不在班级表内放学⽣呢？因为，你想⼀想班级表内如果放学⽣那么记录可能就是这样：1班ID 1班 xx同学id1班ID 1班 xx同学id..这是不允许的，班级表内班级为主键,是唯⼀的不允许相同记录的；下⾯简单讲下⼤概建成的表结构--建班级表create table class(classid int primary key,--定义班级ID为主键classname varchar(15))--建学⽣表create table students(studentid int primary key,--定义学⽣ID为主键classid int ,--外键值，跟班级表classid 属性类型相同stuname varchar(20),--学⽣姓名---定义外键foreign key(classid) references class(classid) --本表classid是基于class表classid的外键)---------如上定义了主外键后，两个表间的关系就是⼀对多的关系了，并且学⽣表内的classid必须依托班级表的classid存在，也就是说外键必须要主键存在的时候才能创建，例如：--在班级表为空的情况往学⽣表插⼊⼀条记录是不允许的：insert into students(studentid,classid,stuname)values(1,1,'⼩明')系统会抛出异常提⽰主键表班级表内班级ID不存在这样是不允许插⼊的；必须要先往班级表内插⼊⼀条记录：insert into class(classid,classname)values(1,'⼀班')后才能执⾏插⼊前⾯⼀条往学⽣表插⼊信息的语句..。
数据库的表关系图
数据库的表关系图1>:one-to-one(一对一关联)主键关联:一对一关联一般可分为主键关联和外键关联主键关联的意思是说关联的两个实体共享一个主键值,但这个主键可以由两个表产生.现在的问题是:*如何让另一个表引用已经生成的主键值解决办法:*Hibernate映射文件中使用主键的foreign生成机制eg:学生表:<hibernate-mapping><class name="er" table="user" catalog="study"><id name="userid" type="ng.Integer"><column name="userid" /><generator class="native" /></id><property name="username" type="ng.String"><column name="username" length="20" /></property><one-to-one name="card" class="org.wen.beans.Card" cascade="all"></one-to-one></class></hibernate-mapping>添加:<one-to-one name="card"class="org.wen.beans.Card"fetch="join"cascade="all" /><class>元素的lazy属性为true,表示延迟加载,如果lazy设为false,则表示立即加载.以下对这二点进行说明.立即加载:表示在从数据库中取得数据组装好一个对象后,会立即再从数据库取得数据组装此对象所关联的对象延迟加载:表示在从数据库中取得数据组装好一个对象后,不会立即从数据库中取得数据组装此对象所关联的对象,而是等到需要时,才会从数据库取得数据组装此关联对象.<one-to-one>元素的fetch属性可选为select和joinjoin:连接抓取,Hibernate通过在Select语句中使用outer join(外连接)来获得对象的关联实例或者关联集合.select:查询抓取,Hibernate需要另外发送一条select语句抓取当前对象的关联实体或集合.******所以我们一般用连接抓取<join>证件表:<hibernate-mapping><class name="org.wen.beans.Card" table="card" lazy="true" catalog="study"><id name="cardid" type="ng.Integer"><column name="cardid" /><generator class="foreign"><param name="property">user</param></generator></id><!-- id使用外键(foreign)生成机制，引用代号为user的对象的主键作为card表的主键和外键。
EFCodefirst多对多关系操作中间表的增删改查（CRUD）
EFCodefirst多对多关系操作中间表的增删改查（CRUD）前⾔此⽂章只是为了给新⼿程序员，和经验不多的程序员，在学习ef和lambada表达式的过程中可能遇到的问题。
本次使⽤订单表和员⼯表建⽴多对多关系。
⾸先是订单表：public class Order{public int OrderId { get; set; }public string OrderTitle { get; set; }public string CustomerName { get; set; }public DateTime TransactionDate { get; set; }[ConcurrencyCheck][Timestamp]public byte[] TimeStamp { get; set; }public virtual ICollection<Employee> InvolvedEmployees { get; set; }}接下来是员⼯表：public class Employee{public int EmployeeId { get; set; }public string EmployeeName { get; set; }public virtual ICollection<Order> Orders { get; set; }}映射⽂件(mapping):public class OrderMap:EntityTypeConfiguration<Order>{public OrderMap(){this.HasKey(o => o.OrderId);//OrderId为⾃增长this.Property(o => o.OrderId).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);this.Property(o => o.OrderTitle).IsRequired().HasMaxLength(64);//订单名称为必填，最⼤长度为64;this.Property(o => o.CustomerName).IsRequired().HasMaxLength(64);//订单名称为必填，最⼤长度为64;this.Property(o => o.TransactionDate).IsRequired(); //订单名称为必填，最⼤长度为64;}}public class EmployeeMap:EntityTypeConfiguration<Employee>{///<summary>///构造函数///</summary>public EmployeeMap(){this.HasKey(x => x.EmployeeId);this.ToTable("Employees");this.Property(x => x.EmployeeName).IsRequired().HasMaxLength(20);//设置多对多的关系 .Map()配置⽤于存储关系的外键列和表。
关系型数据库表与表之间的三种关系
关系型数据库表与表之间的三种关系⼀、⼀对⼀关系：定义：有两个表，在第⼀个表中的某⼀⾏只与第⼆个表中的⼀⾏相关，同时第⼆个表中的某⼀⾏，也只与第⼀个表中的⼀⾏相关，我们称这两个表为⼀对⼀关系。
例如：第⼀张表：ID姓名国籍贡献1001王⼤锤中国万万没想到1002吉泽明步⽇本动作艺术⽚1003⼑锋⼥王未知计划⽣育第⼆张表：ID出⽣⽇期逝世⽇期10011988NULL10021984NULL1003未知3XXX这⾥的第⼀张表的每⼀⾏只与第⼆张表的⼀⾏相对应。
提⽰：⼀对⼀关系是⽐较少见的关系类型。
但在某些情况下，还是会需要使⽤这种类型。
情况⼀：⼀个表包含了太多的数据列情况⼆：将数据分离到不同的表，划分不同的安全级别。
情况三：将常⽤数据列抽取出来组成⼀个表⼆、⼀对多关系：定义：有多张表，第⼀个表中的⾏可以与第⼆个表中的⼀到多个⾏相关联，但是第⼆个表中的⼀⾏只能与第⼀个表中的⼀⾏相关联。
例如：第⼀张表：ID姓名国籍1001王⼤锤中国1002吉泽明步⽇本1003⼑锋⼥王未知第⼆张表：ID节⽬ID100110001100110002100310003100310004第三张表：节⽬ID节⽬名称10001万万没想到10002报告⽼板10003星际210004英雄联盟这⾥的第⼀张表的⼀⾏可以与第⼆张表的多⾏相对应；第⼆张表的⼀⾏与第三张表的⼀⾏相对应。
提⽰：⼀对多关系是最常见的关系类型。
三、多对多关系：定义：有两个表，第⼀个表的⼀⾏可以与第⼆个表中的⼀到多个⾏相关联，同时，第⼆个表中的⼀⾏可以与第⼀个表中的⼀到多个⾏相关联。
例如：第⼀张表：ID姓名国籍1001王⼤锤中国1002吉泽明步⽇本1003⼑锋⼥王未知第⼆张表：ID节⽬ID100110001100110002100310003100310003100310004第三张表：节⽬ID节⽬名称10001万万没想到10002报告⽼板10003星际210004英雄联盟在第⼀张与第三张表之间，⼀个⼈可以参加多个节⽬，⼀个节⽬也可以有多个⼈参加。
数据库设计中一对一、多对一、多对多关系依据外键的实现条件及方法
数据库设计中⼀对⼀、多对⼀、多对多关系依据外键的实现条件及⽅法下⾯以departments和staff_info表为例（为staff_info添加指向departments的外键）⼀个表的字段作为外键的条件：列值必须⾮空且唯⼀测试例⼦如下：mysql> create table departments (dep_id int(4),dep_name varchar(11));Query OK, 0 rows affected (0.02 sec)mysql> desc departments;+----------+-------------+------+-----+---------+-------+| Field | Type | Null | Key | Default | Extra |+----------+-------------+------+-----+---------+-------+| dep_id | int(4) | YES | | NULL | || dep_name | varchar(11) | YES | | NULL | |+----------+-------------+------+-----+---------+-------+rows in set (0.00 sec)# 创建外键不成功mysql> create table staff_info (s_id int,name varchar(20),dep_id int,foreign key(dep_id) references departments(dep_id));ERROR 1215 (HY000): Cannot add foreign key# 设置dep_id⾮空，仍然不能成功创建外键mysql> alter table departments modify dep_id int(4) not null;Query OK, 0 rows affected (0.02 sec)Records: 0 Duplicates: 0 Warnings: 0mysql> desc departments;+----------+-------------+------+-----+---------+-------+| Field | Type | Null | Key | Default | Extra |+----------+-------------+------+-----+---------+-------+| dep_id | int(4) | NO | | NULL | || dep_name | varchar(11) | YES | | NULL | |+----------+-------------+------+-----+---------+-------+rows in set (0.00 sec)mysql> create table staff_info (s_id int,name varchar(20),dep_id int,foreign key(dep_id) references departments(dep_id));ERROR 1215 (HY000): Cannot add foreign key constraint# 当设置字段为unique唯⼀字段时，设置该字段为外键成功mysql> alter table departments modify dep_id int(4) unique;Query OK, 0 rows affected (0.01 sec)Records: 0 Duplicates: 0 Warnings: 0mysql> desc departments;+----------+-------------+------+-----+---------+-------+| Field | Type | Null | Key | Default | Extra |+----------+-------------+------+-----+---------+-------+| dep_id | int(4) | YES | UNI | NULL | || dep_name | varchar(11) | YES | | NULL | |+----------+-------------+------+-----+---------+-------+rows in set (0.01 sec)mysql> create table staff_info (s_id int,name varchar(20),dep_id int,foreign key(dep_id) references departments(dep_id));Query OK, 0 rows affected (0.02 sec)特别注意：需要主外结合的两个表必须是使⽤同样的⼀个引擎类型：两个表必须都是innodb存储引擎添加外键的⽅法⼀般有两种⽅法，在创建表的时候添加，或者后期再添加创建时添加mysql> create table score(-> sid int not null auto_increment primary key,-> student_id int,-> corse_id int,-> number int not null,-> constraint fk_sid foreign key (student_id) references student(sid),-> constraint fk_corse_id foreign key (corse_id) references course(cid));-----------------------------------------------------------------------------------[CONSTRAINT symbol] FOREIGN KEY [id] (从表的字段1)REFERENCES tbl_name (主表的字段2)[ON DELETE {RESTRICT | CASCADE | SET NULL | NO ACTION}][ON UPDATE {RESTRICT | CASCADE | SET NULL | NO ACTION}CONSTRAINT symbol：可以给这个外键约束起⼀个名字，有了名字，以后找到它就很⽅便了。
数据库表关系（单表、一对一、一对多、多对多）
数据库表关系（单表、⼀对⼀、⼀对多、多对多） 写在开头： ⼀直搞不清楚数据库表之间的关系，看了很多博客还是有些弥漫，没有具体的例⼦辅助。
所以写了下⾯的内容，此⽂中的案例以学校为例，个⼈理解，可能会有诸多不妥之处，仅供参考。
⼀、两个重要概念： 什么是主键？外键? 1.主键：主键是表的⼀个特殊字段，可以唯⼀地标识表中的每条信息。
⽐如：⾝份证号。
⼀个表中可以有⼀个或多个主键。
作⽤：唯⼀标识、快速查找 2.外键：如果表B的⼀个字段（外键）依赖于表A的主键。
则成表A为⽗表，表B为⼦表。
原则：外键必须依赖于数据库中已经存在的⽗表的主键，外键可以为空 作⽤：建⽴该表与⽗表的关联关系⼆、表关系 包括单表、多表（⼀对⼀、⼀对多、多对多） 1.单表 就是⼀张表，所有的数据都在⼀张表中。
例：下⾯这张表，学习信息都存在⼀张表中。
2.多表 2.1⼀对⼀（不常⽤）A 表中的⼀⾏最多只能匹配于B 表中的⼀⾏ 应⽤场景： 1.单表太⼤，⼀分为⼆ 2.由于安全原因⽽隔离表的⼀部分 例:为了收集学⽣的联系⽅式，⼜建了⼀张学⽣联系表，如下图。
联系表（⼦表）中的外键（学号），必须依赖于信息表（⽗表）中的主键（学号）存在。
2.2⼀对多A 表中的⼀⾏可以匹配B 表中的多⾏，但是 B 表中的⼀⾏只能匹配 A 表中的⼀⾏ 例：学⽣到校后，需要分班，下⾯的两张表就产⽣了。
⼀个班有多个学⽣，⼀个学⽣只能归属⼀个班级， 2.3多对多 多对多就是两个⼀对多A 表中的⼀⾏可以匹配B 表中的多⾏，反之亦然。
要创建这种关系，需要定义第三个表，称为，它的主键由 A 表和 B 表的外键组成。
例：办级分好之后学⽣就该选课了。
我们需要⼀张课程表。
⼀个学⽣可以选择多门科，⼀门课也可以多名同学上。
此时我们通过第三张表来映射这种关系。
课程表： 学⽣分班表： 选课结果(第三张表）: 。
多对多联系的例子
多对多联系的例子
1.学生-课程：一个学生可以选择多门课程，一门课程也可以被多个学生选择。
2.产品-订单：一个订单可以有多个产品，每个产品也可以出现在多个订单中。
在创建数据库表时，多对多关系需要借助中间表来实现。
例如，学生和课程的关系需要创建一个选课信息表，其中包含学生ID和课程ID两个字段，用于建立学生和课程之间的多对多关系。
其他常见的多对多联系的例子包括：
1.友情关系：一个人可以和多个人建立友情关系，同样，一个人也可以和多个人拥有友谊。
2.共同兴趣小组：一个人可以加入多个兴趣小组，同时一个兴趣小组也可以有多个成员。
3.文章-评论：一篇文章可以有多个评论，同时一个评论者也可以对多篇文章进行评论。
4.书籍-读者：一本书可以由多个读者阅读，同时一个读者也可以阅读多本书籍。
这些例子中的关系都是多对多的，需要通过中间表或者其他方式来建立和管理这种关系。
实体与联系之间的3种对应关系
实体与联系之间的3种对应关系
实体与实体间的联系有三种，包括：一对一关系、多对多关系和一对多关系。
1. 一对一关系（1:1）：表示两个实体之间存在一对一的对应关系，即一个
实体只与另一个实体相关联，反之亦然。
例如，一个乘客只能坐一个机位，一个机位只能由一位乘客乘坐，所以乘客和飞机机位之间的联系是一对一的联系。
2. 一对多关系（1:n）：表示一个实体与多个实体之间存在一对多的对应关系。
例如，一个班级有许多学生，而一个学生只能编入某一个班级，所以班级和学生之间的联系是一对多的联系。
3. 多对多关系（m:n）：表示两个实体之间存在多对多的对应关系，即两个或多个实体相互关联。
例如，一个教师可以讲授多门课程，同一门课程也可以由多个教师讲授，所以教师和课程之间的联系是多对多的联系。
这些对应关系在数据建模、数据库设计、以及日常生活和工作中非常常见，有助于理解不同实体之间的关系并据此进行合理的设计和安排。
一对多、多对一、多对多关系
⼀对多、多对⼀、多对多关系⼀对多、多对⼀在表中表达：外键在对象中的表达：集合（使⽤Set集合）在orm元数据⽂件中配置：在上述实体中添加了相应的集合（Set<LinkMan>）跟对象（Customer）属性后，就得在orm元数据中去配置这两个属性了在⼀的⼀⽅配置（即拥有集合的⼀⽅）在Customer.hbm.xml中写⼊<!--name: 填写集合属性名column: 外键名（数据库表中的外键名）class: 与我关联的类的名称，即多的⼀⽅的实体类名--><set name="linkman"><!-- 要指定的外键列名 --><key column="lkm_cust_id"></key><!-- 指定对应的关系：⼀对多 --><one-to-many class="LinkMan" /></set>在多的⼀⽅配置在LinkMan.hbm.xml中写⼊<!--name: 属性名column: 外键列名class: 与我关联的类的名称，即⼀的⼀⽅的实体类的名称--><many-to-one name="customer" column="lkm_cust_id" class="Customer"></many_to_one>⼀对多关系操作创建客户跟联系⼈，并指定客户对应的联系⼈public void test(){// 获取sessionSession session = HBUtils.CurrentSession();// 获取事务并开启Transaction tx = session.beginTransaction();// -------------------------------------// 创建客户跟联系⼈Customer customer = new Customer();customer.setCust_name("Sacrtlett");// 创建客户LinkMan linkMan = new LinkMan();linkMan.setLkm_name("Eric Jin");LinkMan linkMan1 = new LinkMan();linkMan1.setLkm_name("taylor");// 添加关系customer.getLinkMens().add(linkMan);customer.getLinkMens().add(linkMan1);linkMan.setCustomer(customer);linkMan1.setCustomer(customer);// 保存session.save(customer);session.save(linkMan);session.save(linkMan1);// -------------------------------------// 提交事务mit();}为客户添加联系⼈public void test(){// 获取sessionSession session = HBUtils.CurrentSession();// 获取事务并开启Transaction tx = session.beginTransaction();// -------------------------------------// 获取要操作的客户Customer c = session.get(Customer.class, 1L);// 创建联系⼈LinkMan linkMan = new LinkMan();linkMan.setLkm_name("mike");// 将联系⼈添加到客户，将客户设置到联系⼈中c.getLinkMens().add(linkMan);linkMan.setCustomer(c);// 保存session.save(linkMan);// -------------------------------------// 提交事务mit();}解除客户与联系⼈的关系public void test(){// 获取sessionSession session = HBUtils.CurrentSession();// 获取事务并开启Transaction tx = session.beginTransaction();// -------------------------------------// 获取要操作的客户Customer c = session.get(Customer.class, 1L);// 获取要移除的联系⼈LinkMan lm = session.get(LinkMan.class, 1L);// 将联系⼈从客户集合集合中删除c.getLinkMens().remove(lm);lm.setCustomer(null);// -------------------------------------// 提交事务mit();}多对多在表中表达上⾯的图⽚中，通过第三⽅的⼀张表将Author表跟Book表联系了起来，⽽这第三⽅表最少应该有两列，⼀列是与Author表的id关联的外键，⼀列是与Book表关联的外键。
多对多关系 操作表
多对多关系操作表一、概述在数据库设计中，多对多关系是指两个实体之间存在多对多的关联关系。
例如，在一个图书馆系统中，一个图书可以被多个读者借阅，同时一个读者也可以借阅多本图书。
这种关系无法用单一的外键来表示，需要通过中间表来实现。
多对多关系的操作表用于记录两个实体之间的关联关系，以及关联关系的属性。
本文将详细介绍多对多关系操作表的设计和使用。
二、设计原则在设计多对多关系操作表时，需要遵循以下原则：1.明确关联关系：确定需要建立多对多关系的两个实体，并明确它们之间的关联关系。
2.定义关联关系属性：根据实际需求，确定关联关系的属性，并在操作表中进行定义。
3.唯一标识关联关系：为每个关联关系分配一个唯一的标识符，以便于操作和查询。
4.保持一致性：在操作表中保持数据的一致性，确保每个关联关系都是有效的。
5.简化查询：通过合理的索引设计和查询优化，提高查询效率。
三、操作表设计1. 实体表设计在设计多对多关系操作表之前，需要先设计实体表。
实体表用于存储实体的属性信息。
以图书馆系统为例，可以设计两个实体表：图书表和读者表。
实体表设计示例：图书表（Books）图书编号（ID）主键，自增长图书名称（Name）作者（Author）出版社（Publisher）读者表（Readers）读者表（Readers）读者编号（ID）主键，自增长读者姓名（Name）性别（Gender）年龄（Age）2. 多对多关系操作表设计多对多关系操作表用于记录两个实体之间的关联关系，以及关联关系的属性。
在设计操作表时，需要考虑以下几个方面：2.1 表结构设计操作表结构应包含以下字段：•关联关系编号（ID）：唯一标识关联关系的字段。
•实体1编号（Entity1ID）：关联关系中实体1的编号。
•实体2编号（Entity2ID）：关联关系中实体2的编号。
•关联属性1（Property1）：关联关系的属性1。
•关联属性2（Property2）：关联关系的属性2。
SQL的一对多,多对一，一对一，多对多什么意思？
SQL的⼀对多,多对⼀，⼀对⼀，多对多什么意思？1、⼀对多：⽐如说⼀个班级有很多学⽣，可是这个班级只有⼀个班主任。
在这个班级中随便找⼀个⼈，就会知道他们的班主任是谁；知道了这个班主任就会知道有哪⼏个学⽣。
这⾥班主任和学⽣的关系就是⼀对多。
2、多对⼀：⽐如说⼀个班级有很多学⽣，可是这个班级只有⼀个班主任。
在这个班级中随便找⼀个⼈，就会知道他们的班主任是谁；知道了这个班主任就会知道有哪⼏个学⽣。
这⾥学⽣和班主任的关系就是多对⼀。
3、⼀对⼀：⽐如说⼀个班级有很多学⽣，他们分别有不同的学号。
⼀个学⽣对应⼀个学号，⼀个学号对应⼀个学⽣；通过学号能找到学⽣，通过学⽣也能得到学号，不会重复。
这⾥学⽣和学号的关系就是⼀对⼀。
4、多对多：⽐如说⼀个班级有很多学⽣，他们有语⽂课、数学课、英语课等很多课。
⼀门课有很多⼈上，⼀个⼈上很多门课。
这⾥学⽣和课程的关系就是多对多。
1、⼀对⼀的使⽤⽅法（1）使⽤嵌套结果映射来处理重复的联合结果的⼦集。
（2）通过执⾏另外⼀个SQL映射语句来返回预期的复杂类型。
2、⼀对多的实现⽅法在多的⼀⽅的表⾥⾯，添加外键。
3、多对多的实现⽅法多对多，必须要通过单独的⼀张表来表⽰。
⼀、参照完整性参照完整性指的就是多表之间的设计,主要使⽤外键约束。
多表设计: ⼀对多、多对多、⼀对⼀设计1.⼀对多关联主要语句：constraint cus_ord_fk foreign key (customer_id) REFERENCES customer(id)创建客户表——订单表⼀个客户可以订多份订单，每份订单只能有⼀个客户。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27-- 关联（1对N）create table customer(id int PRIMARY KEY auto_increment,name varchar(20) not null,adress varchar(20) not null);create table orders(order_num varchar(20) PRIMARY KEY,price FLOAT not NULL,customer_id int, -- 进⾏和customer 关联的字段外键constraint cus_ord_fk foreign key(customer_id) REFERENCES customer(id) );insert into customer(name,adress) values("zs","北京");insert into customer(name,adress) values("ls","上海");SELECT* from customer;28 29 30 31 32 33 34INSERT INTO orders values("010",30.5,1); INSERT INTO orders values("011",60.5,2); INSERT INTO orders values("012",120.5,1); SELECT* from orders;notice： constraint: 约束的意思。
数据库中多对多的关系
数据库中多对多的关系数据库中的关系有⼀对⼀、⼀对多、多对多三种。
⼀对⼀很好理解了。
⼀对多，例如员⼯与部门的关系，⼀个员⼯只能属于⼀个部门，⼀个部门拥有多名员⼯，类似这样判断结果的都是⼀对多，没有多对⼀的关系。
多对多，学⽣与⽼师的关系，⼀个⽼师教很多学⽣，⼀个学⽣有不同科⽬的⽼师。
主要看看⼀对多关系和多对多。
建⽴如下表：⼀对多：create table employee(id int auto_increment,name varchar(20) not null,dep_id int not null,primary key(id));insert into employee (name,dep_id) values ("刘备",1),("张飞",2),("关⽻",2)create table department (id int auto_increment,name varchar(20),primary key(id));insert into department (name) values("总经办"),("市场部");alter table employee add foreign key (dep_id) references department (id);//插⼊外键使⽤内部联结查询：select e.id,, from employee e inner join department d on e.dep_id=d.id;查询结果：多对多的表的设计：create table student(id int auto_increment,name varchar(20) not null,primary key(id));insert into student (name) values("张三"),("李四"),("王五"),("赵六")create table teacher(id int auto_increment,name varchar(20) not null,primary key(id));insert into teacher (name) values("赵四"),("李武"),("王九"),("刘师");create table relation(stu_id int not null,tea_id int not null);insert into relation (stu_id,tea_id) values (1,1),(1,2),(1,3),(2,2),(2,3),(3,2),(4,1),(4,2);//添加外键alter table relation add foreign key(stu_id) references student (id);alter table relation add foreign key(tea_id) references teacher (id);查看每个学⽣都选了哪些⽼师：select , fromstudent s inner join relation ron s.id=r.stu_id inner join teacher ton t.id=r.tea_id这样看，不太美观，采⽤分组的形式，并显⽰组内的详细内容：select ,group_concat() fromstudent s inner join relation ron s.id=r.stu_id inner join teacher t on t.id=r.tea_idgroup by ;查询成功！！。
表间的关系一对多一对一多对多关系是怎样建立的？
表间的关系⼀对多⼀对⼀多对多关系是怎样建⽴的？2.外键可以是⼀对⼀的，⼀个表的记录只能与另⼀个表的⼀条记录连接，或者是⼀对多的，⼀个表的记录与另⼀个表的多条记录连接。
1.⼀对多，在多的⼀⽅建⽴外键（外键指向⼀的主键）母亲与孩⼦的关系：母亲，孩⼦两个实体母亲表：ID(P),名字，年龄，性别孩⼦表：ID(P),名字，年龄，性别以上关系：⼀个妈妈可以在孩⼦表中找到多条记录（也可能是⼀条），但是⼀个孩⼦只能找到⼀个妈妈是⼀种典型的⼀对多的关系。
但是以上设计：解决了实体的设计表问题，但是没有解决关系问题，孩⼦找不到母亲，母亲也找不到孩⼦解决⽅案：在某⼀张表中增加⼀个字段，能够找到另外⼀张表中的记录:在孩⼦表中增加⼀个字段指向母亲表，因为孩⼦表的记录只能匹配到⼀条母亲表的记录。
母亲表：ID(P),名字，年龄，性别孩⼦表：ID(P),名字，年龄，性别，母亲表ID（母亲表主键）2.多对多的关系，是通过中间表。
中间表是多的⼀⽅，所以多的⼀⽅要包含指向⼀的⼀⽅的外键。
所以中间表，作为两边多的⼀⽅，中间表要包含两边的外键，两个外键分别指向两张表的主键。
多对多⼀对表中（A）的⼀条记录能够对应另外⼀张表（B）中的多条记录；同时B表中的⼀条记录也能对应A表中的多条记录⽼师和学⽣⽼师表 T_ID(P),姓名，性别学⽣表 S_ID(P),姓名，性别以上设计⽅案：实现了实体的设计，但是没有维护实体的关系⼀个⽼师教过多个学⽣，⼀个学⽣也被多个⽼师教过解决⽅案：增加⼀张中间关系表⽼师与学⽣的关系表：ID(P),T_ID,S_ID⽼师表与中间表形成⼀对多的关系，⽽中间表是多表；维护了能够唯⼀找到⼀表的关系；同样的学⽣表与中间表也是⼀个⼀对多的关系;学⽣找⽼师：找出学⽣ID--->中间表寻找匹配记录（多条）--->⽼师表匹配（⼀条）⽼师找学⽣：找出⽼师ID--->中间表寻找匹配记录（多条）--->学⽣表匹配（⼀条）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据库建表-- 一对多/多对一/一对一/多对多关系
关联映射：一对多/多对一存在最普遍的映射关系，简单来讲就如球员与球队的关系；一对多：从球队角度来说一个球队拥有多个球员即为一对多多对一：从球员角度来说多个球员属于一个球队即为多对一数据表间一对多关系如下图：
关联映射：一对一关系就如球队与球队所在地址之间的关系，一支球队仅有一个地址，而一个地址区也仅有一支球队。
数据表间一对一关系的表现有两种，一种是外键关联，一种是主键关联。
图示如下：
一对一外键关联：
一对一主键关联：要求两个表的主键必须完全一致，通过两个表的主键建立关联关系
关联映射：多对多
多对多关系也很常见，例如学生与选修课之间的关系，一个学生可以选择多门选修课，而每个选修课又可以被多名学生选择。
数据库中的多对多关联关系一般需采用中间表的方式处理，将多对多转化为两个一对多。
数据表间多对多关系如下图：
----------------------------------------------------------------------------------------------------------
前言：多对多关系至少需要3个表，我们把一个表叫做主表，一个叫做关系表，另外一个叫做字典表或者副表（字典表是纪录比较少，而且基本稳定的，例如：版块名称；副表是内容比较多，内容变化的，例如）。
按照数据库的增删查改操作，多对多关系的查找都可以用inner join或者
select * from 主表where id in (select 主表id from 关系表)
1，角色任命型
特点：关系表两外键组合无重复纪录，关系表一般不需要时间字段和主键，有一个表是字典类型的表。
界面特点：显示主表，用checkbox或多选select设置多选关系。
例如：任命版主（用户表-关系表-版块名称表），角色权限控制等，用户是5个版块版主，只要关系表5行纪录就可以确立，关系表的两个外键具有联合主键性质。
增加关系：如果没有组合纪录，insert之。
删除关系：如果有组合纪录，删除之。
2，集合分组型
特点：同角色任命型类似，关系表两外键组合无重复纪录，关系表一般不需要时间字段和主键。
区别是主副表都不是字典表，可能都很大不固定。
界面特点：显示主表，用搜索代替简单的checkbox或多选select，或者一条一条的添加。
例如：歌曲专集（专集表-关系表-歌曲表）。
手机分组（分组表-关系表-手机表）。
用户圈子（圈子表-关系表-用户表）。
文章标签（文章表-关系表-标签表）
增加关系：同版主任命型。
删除关系：同版主任命型。
3，明细帐型
特点：关系表可以有重复纪录，关系表一般有时间字段，有主键，可能还有文字型的字段用来说明每次发生关系的原因（消费）。
界面特点：显示关系表，用radio或下拉设置单选关系。
例如：现金消费明细帐或订单（用户表-订单表-消费原因表），用户可能多次在同一事情上重复消费。
积分变化纪录也属于这类。
增加关系：不管有没有组合纪录，insert之，纪录时间。
删除关系：根据关系表PK删除。
4，评论回复型
特点：同明细帐型关系表一般有时间字段，有主键，区别是重点在文字型的字段用来说明每次发生关系的内容（评论回复）。
界面特点：回复文本框。
例如：论坛回复（用户表-回复表-帖子表），用户可能多次在不同帖子上评论回复费。
增加关系：不管有没有组合纪录，insert之，纪录时间和文字。
删除关系：根据关系表（回复表）PK删除。
5，站内短信型
特点：主副表是同一个，关系表一般有时间字段，有主键，重点在关系表文字型的字段用来说明每次发生关系的内容（消息）或者其他标记位来表示文字已读状态时间等。
界面特点：回复文本框。
例如：站内短信（用户表-短信表-用户表），用户可能给用户群发或者单发，有标记位来表示文字已读状态时间等。
增加关系：不管有没有组合纪录，insert之，纪录时间和文字。
删除关系：根据关系表（回复表）PK删除。
6，用户好友型
特点：主副表是同一个，同集合分组型，关系表两外键组合无重复纪录，关系表一般不需要时间字段和主键。
界面特点：同集合分组型，显示主表，用搜索代替简单的checkbox或多选select，或者一条一条的添加。
例如：下载站点的文件，（文件表-关系表-文件表）可以被软件工具打开，软件工具本身也是一种文件，可以被下载。
用户的好友，也是用户（用户表-好友关系表-用户表）
增加关系：同版主任命型。
删除关系：同版主任命型。
7，未知属性型
特点：在设计初期，主表的某些字段类型和名称是不确定的时候，关系表实际上是主表的可扩展字段，一个[主表]（ID），
一个[属性名称表]（属性ID.属性名称)，
一个[属性值表]，包括3个字段：
属性值(属性Value varchar(500))
主表ID
属性ID
这样可以作到最小冗余度。
（和常见的多对多关系不同的是：值统一用varchar来存储，因为这类型的值一般不会用来计算）。
比如：
军队的数据库设计中有种物资叫做“战缴物资”，就是打仗的时候缴获的，军队自己都不知道这些物资有什么属性。
比如缴获的化学品有化学名，通用名，是否有辐射，计量单位，包装规格，数量等等，或者不是化学品是其他任何未知的东西。
这样东西就可以
某奇怪东西.属性集合["某某奇怪属性名"]="某某奇怪值"；
某变态东西.属性集合["某某变态属性名"]="某某变态值"；
这样存储。
再比如：
手机型号有几千种，除了共同属性外还有不同属性有几百个，属性名和值类型都不一样，有的手机有这属性，有的没有。
对于这样的“多态”，我们就采用上面的设计结构。
其效果相当于：
某奇怪手机.属性集合["某某奇怪属性名"]="某某奇怪值"；
某变态手机.属性集合["某某变态属性名"]="某某变态值"；
界面特点：设置主表一行纪录的属性时候，要列出所有可能的属性名称，每个对应一个文本框。