精华内容
下载资源
问答
  • 在表关系里,多对多用得比较多,一对多,然后才一对一  数据库中“一对一”、“一对多”、“多对多”的判断方法 多对多:一个老师可以教多个学生,一个学生可以有多个老师教。 一对多:一个父亲可以有多个亲生孩子,一...
  • 转自:https://blog.csdn.net/zhongshan_c/article/details/8210196数据库建表-- 一对多/多对一/一对一/多对多 关系 关联映射:一对多/多对一存在最普遍的映射关系,简单来讲就如球员与球队的关系;一对多:从...
    

    转自:

    https://blog.csdn.net/zhongshan_c/article/details/8210196

    数据库建表-- 一对多/多对一/一对一/多对多 关系

    关联映射:一对多/多对一存在最普遍的映射关系,简单来讲就如球员与球队的关系;一对多:从球队角度来说一个球队拥有多个球员 即为一对多多对一:从球员角度来说多个球员属于一个球队 即为多对一数据表间一对多关系如下图:

    注:一对多/多对一关系简记:“多”的要记住“一”的主键,即每个球员表都要通过外键来记住球队表。

    关联映射:一对一关系就如球队与球队所在地址之间的关系,一支球队仅有一个地址,而一个地址区也仅有一支球队。数据表间一对一关系的表现有两种,一种是外键关联,一种是主键关联。图示如下:
    一对一外键关联:

    一对一主键关联:要求两个表的主键必须完全一致,通过两个表的主键建立关联关系

     

    关联映射:多对多

    多对多关系也很常见,例如学生与选修课之间的关系,一个学生可以选择多门选修课,而每个选修课又可以被多名学生选择。 数据库中的多对多关联关系一般需采用中间表的方式处理,将多对多转化为两个一对多。

    数据表间多对多关系如下图:

    ----------------------------------------------------------------------------------------------------------

    前言:多对多关系至少需要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来存储,因为这类型的值一般不会用来计算)。

    比如:

    军队的数据库设计中有种物资叫做“战缴物资”,就是打仗的时候缴获的,军队自己都不知道这些物资有什么属性。

    比如缴获的化学品有化学名,通用名,是否有辐射,计量单位,包装规格,数量等等,或者不是化学品是其他任何未知的东西。 
    这样东西就可以

    某奇怪东西.属性集合["某某奇怪属性名"]="某某奇怪值";    
    某变态东西.属性集合["某某变态属性名"]="某某变态值";   

    这样存储。

    再比如:

    手机型号有几千种,除了共同属性外还有不同属性有几百个,属性名和值类型都不一样,有的手机有这属性,有的没有。 
    对于这样的“多态”,我们就采用上面的设计结构。 
    其效果相当于:

    某奇怪手机.属性集合["某某奇怪属性名"]="某某奇怪值"; 
    某变态手机.属性集合["某某变态属性名"]="某某变态值";

    界面特点:设置主表一行纪录的属性时候,要列出所有可能的属性名称,每个对应一个文本框。

    展开全文
  • Spring data 数据库建表一对一,一对多,多对多) 摘要: DBA 如果你在不学习编程,你将失业。如今我们对DBA的依赖越来越少,多数框架都支持实体关系映射,通过面向对象编程即可定义数据库结构。数据库设计也...
    Spring data 数据库建表(一对一,一对多,多对多)
     
    摘要: DBA 如果你在不学习编程,你将失业。如今我们对DBA的依赖越来越少,多数框架都支持实体关系映射,通过面向对象编程即可定义数据库结构。数据库设计也是在这个阶段完成的,不再需要DBA协助。如果DBA不学习怎样编写实体Class 最终将被淘汰。所以DBA除了会使用 ER图工具,还需要会写实体类。

    Spring data 数据库建表(一对一,一对多,多对多) 

    2017-07-25 景峯 Netkiller

    本文节选择电子书《Netkiller Java 手札》

     

    DBA 如果你在不学习编程,你将失业。如今我们对DBA的依赖越来越少,多数框架都支持实体关系映射,通过面向对象编程即可定义数据库结构。数据库设计也是在这个阶段完成的,不再需要DBA协助。如果DBA不学习怎样编写实体Class 最终将被淘汰。所以DBA除了会使用 ER图工具,还需要会写实体类。

     

    8.3.1.9. @OneToOne

    一对一表结构,如下面ER图所示,users表是用户表里面有登陆信息,profile 保存的时死人信息,这样的目的是我们尽量减少users表的字段,在频繁操作该表的时候性能比较好,另外一个目的是为了横向水平扩展。

    +----------+             +------------+
        | users    |             | profile    |
        +----------+             +------------+
        | id       | <---1:1---o | id         |
        | name     |             | sex        |    
        | password |             | email      |    
        +----------+             +------------+| users    |             | profile    |
        +----------+             +------------+
        | id       | <---1:1---o | id         |
        | name     |             | sex        |    
        | password |             | email      |    
        +----------+             +------------+
    package com.example.api.domain.test;
    
    import java.io.Serializable;
    
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.Table;
    
    @Entity
    @Table(name = "users")
    public class Users implements Serializable {
    	@Id
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	private int id;
    	private String name;
    	private String password;
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public String getPassword() {
    		return password;
    	}
    
    	public void setPassword(String password) {
    		this.password = password;
    	}
    
    	@Override
    	public String toString() {
    		return "Users [id=" + id + ", name=" + name + ", password=" + password + "]";
    	}
    } com.example.api.domain.test;
    
    import java.io.Serializable;
    
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.Table;
    
    @Entity
    @Table(name = "users")
    public class Users implements Serializable {
    	@Id
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	private int id;
    	private String name;
    	private String password;
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public String getPassword() {
    		return password;
    	}
    
    	public void setPassword(String password) {
    		this.password = password;
    	}
    
    	@Override
    	public String toString() {
    		return "Users [id=" + id + ", name=" + name + ", password=" + password + "]";
    	}
    }
    package com.example.api.domain.test;
    
    import java.io.Serializable;
    
    import javax.persistence.Entity;
    import javax.persistence.Id;
    import javax.persistence.JoinColumn;
    import javax.persistence.OneToOne;
    import javax.persistence.Table;
    
    @Entity
    @Table(name = "profile")
    public class Profile implements Serializable {
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = -2500499458196257167L;
    	@Id
    	@OneToOne
    	@JoinColumn(name = "id")
    	private Users users;
    
    	private int age;
    	private String sex;
    	private String email;
    
    	public Users getUsers() {
    		return users;
    	}
    
    	public void setUsers(Users users) {
    		this.users = users;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	public String getSex() {
    		return sex;
    	}
    
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    
    	public String getEmail() {
    		return email;
    	}
    
    	public void setEmail(String email) {
    		this.email = email;
    	}
    
    	@Override
    	public String toString() {
    		return "Profile [users=" + users + ", age=" + age + ", sex=" + sex + ", email=" + email + "]";
    	}
    
    } com.example.api.domain.test;
    
    import java.io.Serializable;
    
    import javax.persistence.Entity;
    import javax.persistence.Id;
    import javax.persistence.JoinColumn;
    import javax.persistence.OneToOne;
    import javax.persistence.Table;
    
    @Entity
    @Table(name = "profile")
    public class Profile implements Serializable {
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = -2500499458196257167L;
    	@Id
    	@OneToOne
    	@JoinColumn(name = "id")
    	private Users users;
    
    	private int age;
    	private String sex;
    	private String email;
    
    	public Users getUsers() {
    		return users;
    	}
    
    	public void setUsers(Users users) {
    		this.users = users;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	public String getSex() {
    		return sex;
    	}
    
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    
    	public String getEmail() {
    		return email;
    	}
    
    	public void setEmail(String email) {
    		this.email = email;
    	}
    
    	@Override
    	public String toString() {
    		return "Profile [users=" + users + ", age=" + age + ", sex=" + sex + ", email=" + email + "]";
    	}
    
    }
    CREATE TABLE `users` (
    	`id` INT(11) NOT NULL AUTO_INCREMENT,
    	`name` VARCHAR(255) NULL DEFAULT NULL,
    	`password` VARCHAR(255) NULL DEFAULT NULL,
    	PRIMARY KEY (`id`)
    )
    COLLATE='utf8_general_ci'
    ENGINE=InnoDB;
    			
    CREATE TABLE `profile` (
    	`age` INT(11) NOT NULL,
    	`email` VARCHAR(255) NULL DEFAULT NULL,
    	`sex` VARCHAR(255) NULL DEFAULT NULL,
    	`id` INT(11) NOT NULL,
    	PRIMARY KEY (`id`),
    	CONSTRAINT `FK6x079ilawxjrfsljwyyi5ujjq` FOREIGN KEY (`id`) REFERENCES `users` (`id`)
    )
    COLLATE='utf8_general_ci'
    ENGINE=InnoDB; TABLE `users` (
    	`id` INT(11) NOT NULL AUTO_INCREMENT,
    	`name` VARCHAR(255) NULL DEFAULT NULL,
    	`password` VARCHAR(255) NULL DEFAULT NULL,
    	PRIMARY KEY (`id`)
    )
    COLLATE='utf8_general_ci'
    ENGINE=InnoDB;
    			
    CREATE TABLE `profile` (
    	`age` INT(11) NOT NULL,
    	`email` VARCHAR(255) NULL DEFAULT NULL,
    	`sex` VARCHAR(255) NULL DEFAULT NULL,
    	`id` INT(11) NOT NULL,
    	PRIMARY KEY (`id`),
    	CONSTRAINT `FK6x079ilawxjrfsljwyyi5ujjq` FOREIGN KEY (`id`) REFERENCES `users` (`id`)
    )
    COLLATE='utf8_general_ci'
    ENGINE=InnoDB;

    如果第二张表关联的并非主表的PK(主键)需要使用 referencedColumnName 指定。

    @JoinColumn(name = "member_id",referencedColumnName="member_id")JoinColumn(name = "member_id",referencedColumnName="member_id")

    8.3.1.10. OneToMany 一对多

    我们要实现一个一对多实体关系,ER 图如下

    +----------+          +------------+
        | Classes  |          | Student    |
        +----------+          +------------+
        | id       | <---+    | id         |
        | name     |     |    | name       |    
        +----------+     +--o | classes_id |    
                              +------------+| Classes  |          | Student    |
        +----------+          +------------+
        | id       | <---+    | id         |
        | name     |     |    | name       |    
        +----------+     +--o | classes_id |    
                              +------------+

    classes 表需要 OneToMany 注解,Student 表需要 ManyToOne 注解,这样就建立起了表与表之间的关系

    package com.example.api.domain.test;
    
    import java.io.Serializable;
    import java.util.Set;
    
    import javax.persistence.CascadeType;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.OneToMany;
    import javax.persistence.Table;
    
    @Entity 
    @Table(name="classes") 
    public class Classes implements Serializable{
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = -5422905745519948312L;
    	@Id 
    	@GeneratedValue(strategy=GenerationType.AUTO) 
    	private int id; 
    	private String name; 
    	    
    	@OneToMany(cascade=CascadeType.ALL,mappedBy="classes")    
    	private Set<Student> students;
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public Set<Student> getStudents() {
    		return students;
    	}
    
    	public void setStudents(Set<Student> students) {
    		this.students = students;
    	}
    
    	@Override
    	public String toString() {
    		return "classes [id=" + id + ", name=" + name + ", students=" + students + "]";
    	} 
    } com.example.api.domain.test;
    
    import java.io.Serializable;
    import java.util.Set;
    
    import javax.persistence.CascadeType;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.OneToMany;
    import javax.persistence.Table;
    
    @Entity 
    @Table(name="classes") 
    public class Classes implements Serializable{
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = -5422905745519948312L;
    	@Id 
    	@GeneratedValue(strategy=GenerationType.AUTO) 
    	private int id; 
    	private String name; 
    	    
    	@OneToMany(cascade=CascadeType.ALL,mappedBy="classes")    
    	private Set<Student> students;
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public Set<Student> getStudents() {
    		return students;
    	}
    
    	public void setStudents(Set<Student> students) {
    		this.students = students;
    	}
    
    	@Override
    	public String toString() {
    		return "classes [id=" + id + ", name=" + name + ", students=" + students + "]";
    	} 
    }
    package com.example.api.domain.test;
    
    import java.io.Serializable;
    
    import javax.persistence.CascadeType;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.JoinColumn;
    import javax.persistence.ManyToOne;
    import javax.persistence.Table;
    
    @Entity
    @Table(name = "student")
    public class Student implements Serializable{
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 6737037465677800326L;
    	@Id
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	private int id;
    	private String name;
    
    	// 若有多个cascade,可以是:{CascadeType.PERSIST,CascadeType.MERGE}
    	@ManyToOne(cascade = { CascadeType.ALL })
    	@JoinColumn(name = "classes_id") 
    	private Classes classes;
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public Classes getClasses() {
    		return classes;
    	}
    
    	public void setClasses(Classes classes) {
    		this.classes = classes;
    	}
    
    	@Override
    	public String toString() {
    		return "Student [id=" + id + ", name=" + name + ", classes=" + classes + "]";
    	}
    
    } com.example.api.domain.test;
    
    import java.io.Serializable;
    
    import javax.persistence.CascadeType;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.JoinColumn;
    import javax.persistence.ManyToOne;
    import javax.persistence.Table;
    
    @Entity
    @Table(name = "student")
    public class Student implements Serializable{
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 6737037465677800326L;
    	@Id
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	private int id;
    	private String name;
    
    	// 若有多个cascade,可以是:{CascadeType.PERSIST,CascadeType.MERGE}
    	@ManyToOne(cascade = { CascadeType.ALL })
    	@JoinColumn(name = "classes_id") 
    	private Classes classes;
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public Classes getClasses() {
    		return classes;
    	}
    
    	public void setClasses(Classes classes) {
    		this.classes = classes;
    	}
    
    	@Override
    	public String toString() {
    		return "Student [id=" + id + ", name=" + name + ", classes=" + classes + "]";
    	}
    
    }

    最终 SQL 表如下

    CREATE TABLE `classes` (
    	`id` INT(11) NOT NULL AUTO_INCREMENT,
    	`name` VARCHAR(255) NULL DEFAULT NULL,
    	PRIMARY KEY (`id`)
    )
    COLLATE='utf8_general_ci'
    ENGINE=InnoDB;	
    			
    CREATE TABLE `student` (
    	`id` INT(11) NOT NULL AUTO_INCREMENT,
    	`name` VARCHAR(255) NULL DEFAULT NULL,
    	`class_id` INT(11) NULL DEFAULT NULL,
    	PRIMARY KEY (`id`),
    	INDEX `FKnsl7w2nw6o6eq53hqlxfcijpm` (`class_id`),
    	CONSTRAINT `FKnsl7w2nw6o6eq53hqlxfcijpm` FOREIGN KEY (`class_id`) REFERENCES `classes` (`id`)
    )
    COLLATE='utf8_general_ci'
    ENGINE=InnoDB; TABLE `classes` (
    	`id` INT(11) NOT NULL AUTO_INCREMENT,
    	`name` VARCHAR(255) NULL DEFAULT NULL,
    	PRIMARY KEY (`id`)
    )
    COLLATE='utf8_general_ci'
    ENGINE=InnoDB;	
    			
    CREATE TABLE `student` (
    	`id` INT(11) NOT NULL AUTO_INCREMENT,
    	`name` VARCHAR(255) NULL DEFAULT NULL,
    	`class_id` INT(11) NULL DEFAULT NULL,
    	PRIMARY KEY (`id`),
    	INDEX `FKnsl7w2nw6o6eq53hqlxfcijpm` (`class_id`),
    	CONSTRAINT `FKnsl7w2nw6o6eq53hqlxfcijpm` FOREIGN KEY (`class_id`) REFERENCES `classes` (`id`)
    )
    COLLATE='utf8_general_ci'
    ENGINE=InnoDB;
    Classes classes=new Classes(); 
          classes.setName("One"); 
            
          Student st1=new Student(); 
          st1.setSname("jason"); 
          st1.setClasses(classes); 
          studentRepostitory.save(st1); 
            
          Student st2=new Student(); 
          st2.setSname("neo"); 
          st2.setClasses(classes); 
          studentRepostitory.save(st2);new Classes(); 
          classes.setName("One"); 
            
          Student st1=new Student(); 
          st1.setSname("jason"); 
          st1.setClasses(classes); 
          studentRepostitory.save(st1); 
            
          Student st2=new Student(); 
          st2.setSname("neo"); 
          st2.setClasses(classes); 
          studentRepostitory.save(st2);

    8.3.1.11. ManyToMany 多对多

    用户与角色就是一个多对多的关系,多对多是需要中间表做关联的。所以我方需要一个 user_has_role 表。

    +----------+          +---------------+            +--------+
        | users    |          | user_has_role |            | role   |
        +----------+          +---------------+            +--------+
        | id       | <------o | user_id       |      /---> | id     |
        | name     |          | role_id       | o---+      | name   |
        | password |          |               |            |        |
        +----------+          +---------------+            +--------+| users    |          | user_has_role |            | role   |
        +----------+          +---------------+            +--------+
        | id       | <------o | user_id       |      /---> | id     |
        | name     |          | role_id       | o---+      | name   |
        | password |          |               |            |        |
        +----------+          +---------------+            +--------+

    创建 User 表

    package com.example.api.domain.test;
    
    import java.io.Serializable;
    import java.util.Set;
    
    import javax.persistence.Entity;
    import javax.persistence.FetchType;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.JoinTable;
    import javax.persistence.ManyToMany;
    import javax.persistence.Table;
    import javax.persistence.JoinColumn;
    
    @Entity
    @Table(name = "users")
    public class Users implements Serializable {
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = -2480194112597046349L;
    	@Id
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	private int id;
    	private String name;
    	private String password;
    
    	@ManyToMany(fetch = FetchType.EAGER)
    	@JoinTable(name = "user_has_role", joinColumns = { @JoinColumn(name = "user_id", referencedColumnName = "id") }, inverseJoinColumns = { @JoinColumn(name = "role_id", referencedColumnName = "id") })
    	private Set<Roles> roles;
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public String getPassword() {
    		return password;
    	}
    
    	public void setPassword(String password) {
    		this.password = password;
    	}
    
    	public Set<Roles> getRoles() {
    		return roles;
    	}
    
    	public void setRoles(Set<Roles> roles) {
    		this.roles = roles;
    	}
    
    	@Override
    	public String toString() {
    		return "Users [id=" + id + ", name=" + name + ", password=" + password + ", roles=" + roles + "]";
    	}
    
    } com.example.api.domain.test;
    
    import java.io.Serializable;
    import java.util.Set;
    
    import javax.persistence.Entity;
    import javax.persistence.FetchType;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.JoinTable;
    import javax.persistence.ManyToMany;
    import javax.persistence.Table;
    import javax.persistence.JoinColumn;
    
    @Entity
    @Table(name = "users")
    public class Users implements Serializable {
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = -2480194112597046349L;
    	@Id
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	private int id;
    	private String name;
    	private String password;
    
    	@ManyToMany(fetch = FetchType.EAGER)
    	@JoinTable(name = "user_has_role", joinColumns = { @JoinColumn(name = "user_id", referencedColumnName = "id") }, inverseJoinColumns = { @JoinColumn(name = "role_id", referencedColumnName = "id") })
    	private Set<Roles> roles;
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public String getPassword() {
    		return password;
    	}
    
    	public void setPassword(String password) {
    		this.password = password;
    	}
    
    	public Set<Roles> getRoles() {
    		return roles;
    	}
    
    	public void setRoles(Set<Roles> roles) {
    		this.roles = roles;
    	}
    
    	@Override
    	public String toString() {
    		return "Users [id=" + id + ", name=" + name + ", password=" + password + ", roles=" + roles + "]";
    	}
    
    }

    创建 Role 表

    package com.example.api.domain.test;
    
    import java.io.Serializable;
    import java.util.Set;
    
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.ManyToMany;
    import javax.persistence.Table;
    
    @Entity
    @Table(name = "roles")
    public class Roles implements Serializable {
    	private static final long serialVersionUID = 6737037465677800326L;
    	@Id
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	private int id;
    	private String name;
    	@ManyToMany(mappedBy = "roles")
    	private Set<Users> users;
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public Set<Users> getUsers() {
    		return users;
    	}
    
    	public void setUsers(Set<Users> users) {
    		this.users = users;
    	}
    
    	@Override
    	public String toString() {
    		return "Roles [id=" + id + ", name=" + name + ", users=" + users + "]";
    	}
    
    } com.example.api.domain.test;
    
    import java.io.Serializable;
    import java.util.Set;
    
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.ManyToMany;
    import javax.persistence.Table;
    
    @Entity
    @Table(name = "roles")
    public class Roles implements Serializable {
    	private static final long serialVersionUID = 6737037465677800326L;
    	@Id
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	private int id;
    	private String name;
    	@ManyToMany(mappedBy = "roles")
    	private Set<Users> users;
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public Set<Users> getUsers() {
    		return users;
    	}
    
    	public void setUsers(Set<Users> users) {
    		this.users = users;
    	}
    
    	@Override
    	public String toString() {
    		return "Roles [id=" + id + ", name=" + name + ", users=" + users + "]";
    	}
    
    }

    最终产生数据库表如下

    CREATE TABLE `users` (
    	`id` INT(11) NOT NULL AUTO_INCREMENT,
    	`name` VARCHAR(255) NULL DEFAULT NULL,
    	`password` VARCHAR(255) NULL DEFAULT NULL,
    	PRIMARY KEY (`id`)
    )
    COLLATE='utf8_general_ci'
    ENGINE=InnoDB;	
    
    CREATE TABLE `roles` (
    	`id` INT(11) NOT NULL AUTO_INCREMENT,
    	`name` VARCHAR(255) NULL DEFAULT NULL,
    	PRIMARY KEY (`id`)
    )
    COLLATE='utf8_general_ci'
    ENGINE=InnoDB;
    			
    CREATE TABLE `user_has_role` (
    	`user_id` INT(11) NOT NULL,
    	`role_id` INT(11) NOT NULL,
    	PRIMARY KEY (`user_id`, `role_id`),
    	INDEX `FKsvvq61v3koh04fycopbjx72hj` (`role_id`),
    	CONSTRAINT `FK2dl1ftxlkldulcp934i3125qo` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`),
    	CONSTRAINT `FKsvvq61v3koh04fycopbjx72hj` FOREIGN KEY (`role_id`) REFERENCES `roles` (`id`)
    )
    COLLATE='utf8_general_ci'
    ENGINE=InnoDB; TABLE `users` (
    	`id` INT(11) NOT NULL AUTO_INCREMENT,
    	`name` VARCHAR(255) NULL DEFAULT NULL,
    	`password` VARCHAR(255) NULL DEFAULT NULL,
    	PRIMARY KEY (`id`)
    )
    COLLATE='utf8_general_ci'
    ENGINE=InnoDB;	
    
    CREATE TABLE `roles` (
    	`id` INT(11) NOT NULL AUTO_INCREMENT,
    	`name` VARCHAR(255) NULL DEFAULT NULL,
    	PRIMARY KEY (`id`)
    )
    COLLATE='utf8_general_ci'
    ENGINE=InnoDB;
    			
    CREATE TABLE `user_has_role` (
    	`user_id` INT(11) NOT NULL,
    	`role_id` INT(11) NOT NULL,
    	PRIMARY KEY (`user_id`, `role_id`),
    	INDEX `FKsvvq61v3koh04fycopbjx72hj` (`role_id`),
    	CONSTRAINT `FK2dl1ftxlkldulcp934i3125qo` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`),
    	CONSTRAINT `FKsvvq61v3koh04fycopbjx72hj` FOREIGN KEY (`role_id`) REFERENCES `roles` (`id`)
    )
    COLLATE='utf8_general_ci'
    ENGINE=InnoDB;
     

    Donations (打赏)

    We accept PayPal through:

    https://www.paypal.me/netkiller

    Wechat (微信) / Alipay (支付宝) 打赏:

    http://www.netkiller.cn/home/donations.html

     

    作者相关文章:

    Apache Sqoop 将mysql导入到Hadoop HDFS

    Spring boot with Apache Hive

    Apache Hive 快速入门

    CentOS 7.3 + Server JRE 1.8 + Hadoop-2.8.0

    Apache Hbase 快速入门

    Spring cloud 之 Feign Client

    Spring Cloud Netflix

    重新整理AUTO_INCREMENT字段

    Spring Cloud Config

    Spring boot with Schedule (启用/禁用)

    Spring boot with HTTPS SSL

    Spring boot with Git version

    《Netkiller Virtualization 手札》Docker 卷管理

    PHP高级编程之守护进程

    Spring boot with Docker

    Spring boot with Service

    Spring boot with PostgreSQL

    Struts2 S2-046, S2-045 Firewall(漏洞防火墙)

    数据库与图片完美解决方案

    数据库进程间通信解决方案

    数据库进程间通信解决方案之MQ

    Linux 系统安全与优化配置

    Tomcat 安全配置与性能优化

    Linux 系统与数据库安全

     

    转载请注明出处与作者声明,扫描二维码关注作者公众好,不定期更新文章

    展开全文
  • photo_favour(图片收藏关系表):photo_id user_id 假设这几个表都相当大,需要进行分表。我的分表规则是: user表按照id取模,这样user相关的表都可以按照这个取模后的结果来分表; photo表按照id取模,...
    
    

    MYSQL里面有如下的表

    <ol class="linenums"><li class="L0"><span class="pln">user</span><span class="pun">:</span><span class="pln">id username</span> 
    </li><li class="L1"><span class="pln">photo</span><span class="pun">:</span><span class="pln">id name</span> 
    </li><li class="L2"><span class="pln">photo_favour</span><span class="pun">(图片收藏关系表):</span><span class="pln">photo_id user_id</span></li></ol>

    假设这几个表都相当大,需要进行分表。我的分表规则是:
    user表按照id取模,这样user相关的表都可以按照这个取模后的结果来分表;
    photo表按照id取模,同样与photo相关的表都可以按该规则分表;
    至于photo_favour是一个多对多的关系表,我现在的想法是该表复制多一份,一份以photo_id来分表,一份以user_id分表,分别建立不同的索引,这样就变为两个一对多的关系。

    我有两个问题:
    1、这样的分表可行吗,有更好的分表方法吗?
    2、一对多的关系在进行分表时候,例如user表和user_favour表都按照user_id来取模得到序号x来确定分表。如果1个用户会有100条收藏记录,那么user_x有100W条记录时候user_favour_x分表就有1000W记录,这时候user_favour_x又需要分表了,怎么解决这种情况?


    这种情况我会放弃多对多的形式,弄两个表
    user_to_photos: user_id, photo_id_list
    photo_to_users: photo_id, user_id_list

    1个user喜欢的photo id全塞到photo_id_list
    1个photo被哪些用户喜欢了,也全塞到user_id_list

    这样的读取就高效了很多,,写的时候注意并发脏写。。。同样你根据user_id爱怎么分表就怎么分。

    ===

    如果收藏量太大,还是不能满足,就要考虑切分记录,1个user可以拥有多条记录,每条记录都可记录多个photo id
    user_to_photos: user_id, num, photo_id_list

    num字段可有可无,如果你需要精确定位user 222 收藏的 photo 333在哪条记录,就需要安排好算法,找到对应的num

    大概是这样,重点是算法逻辑



    数据库中建表时经常所说一对一、一对多、多对多等等关系究竟是什么意思?分别在什么情况下要用到一对一或一对式,而又在什么情况下又要用到多对多?在这里我们详细分析,并且用实例来讲解各种关系的实际运用!

    关联映射:一对多/多对一存在最普遍的映射关系,简单来讲就如球员与球队的关系;一对多:从球队角度来说一个球队拥有多个球员 即为一对多多对一:从球员角度来说多个球员属于一个球队 即为多对一数据表间一对多关系如下图:

    \

     
     

     

     

     

    关联映射:一对一关系就如球队与球队所在地址之间的关系,一支球队仅有一个地址,而一个地址区也仅有一支球队。数据表间一对一关系的表现有两种,一种是外键关联,一种是主键关联。图示如下:
    一对一外键关联:

    \

     

     

     

    \

     

     

     

     

     

     

     

    ----------------------------------------------------------------------------------------------------------

    前言:多对多关系至少需要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来存储,因为这类型的值一般不会用来计算)。

    比如:

    军队的数据库设计中有种物资叫做“战缴物资”,就是打仗的时候缴获的,军队自己都不知道这些物资有什么属性。

    比如缴获的化学品有化学名,通用名,是否有辐射,计量单位,包装规格,数量等等,或者不是化学品是其他任何未知的东西。 
    这样东西就可以

    某奇怪东西.属性集合["某某奇怪属性名"]="某某奇怪值";    
    某变态东西.属性集合["某某变态属性名"]="某某变态值";   

    这样存储。

    再比如:

    手机型号有几千种,除了共同属性外还有不同属性有几百个,属性名和值类型都不一样,有的手机有这属性,有的没有。 
    对于这样的“多态”,我们就采用上面的设计结构。 
    其效果相当于:

    某奇怪手机.属性集合["某某奇怪属性名"]="某某奇怪值"; 
    某变态手机.属性集合["某某变态属性名"]="某某变态值";

    界面特点:设置主表一行纪录的属性时候,要列出所有可能的属性名称,每个对应一个文本框。

    展开全文
  • 关系, 通常我们建立个中间表,关联另外两个表的主键; 中间表不要多余信息,且另外两张表信息不重复。 表1:学生 表3:爱好 中间表2:学生id;爱好id; Oracle 建表:打开SQLWindows—输入建表语句,执行...
    1. 多对多关系

    通常我们建立一个中间表,关联另外两个表的主键;
    中间表不要多余信息,且另外两张表信息不重复。

    表1:学生
    表3:爱好
    中间表2:学生id;爱好id;

    1. Oracle

    建表:打开SQLWindows—输入建表语句,执行运行-----插入具体数据,复制insert语句,同样运行,再submit!!!
    在这里插入图片描述

    展开全文
  • 数据库建表

    2019-10-29 17:15:58
    ①一个用户有多个订单(用户与订单之间是 一对一关系) ②一个订单可包含多个商品,一个商品可以被多个订单下单 (商品与订单之间是 多对多关系) (三)建库、建表 create databases shopingmall; use ...
  • 数据库建表原则

    2014-03-09 19:06:40
    在一般情况下,它们是一对一关系:即一张原始单据对应且只对应一个实体。在特殊情况下,它们可能是一对多或多对一的关系,即一张原始单证对应多个实体,或多张原始单证对应一个实体。这里的实体可以理解为基本表。...
  • 1.数据库建表

    2018-12-04 16:12:00
    数据库与表的关系一对多 SQL:结构化查询语言,是用来访问和处理数据库的标准计算机语言 SQL(1)创建数据库、表等数据库对象 (2)数据库记录的增删改查 注释的方式: 单行(1)输入 ‘--’+空格 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 488
精华内容 195
关键字:

数据库一对一关系建表