精华内容
下载资源
问答
  • Django 模型种可以定义三种最常见的数据库关联关系多对一,多对多,一对一。我们先来讲讲多对一关联关系。 1 定义 使用 django.db.models.ForeignKey 类,就可以定义出一个多对一的关联关系。在模型中,添加一个值...

    Django 模型种可以定义三种最常见的数据库关联关系:多对一,多对多,一对一。我们先来讲讲多对一关联关系。

    1 定义

    使用 django.db.models.ForeignKey 类,就可以定义出一个多对一的关联关系。在模型中,添加一个值,作为ForeignKey 类的实例。 ForeignKey 类有一个入参,用于定义想要关联的模型类名。

    例如,一个出版社(Press),会出版很多种类的书(Book),而每种书仅来自于一个出版社。那么书与出版社之间,就是多对一的关系:

    class Press(models.Model):
        name = models.CharField(max_length=50)
    
    
    class Book(models.Model):
        name = models.CharField('书名', max_length=50, primary_key=True)
        press = models.ForeignKey(Press, on_delete=models.CASCADE,default='1')
    
    

    makemigrations 初始化 py 脚本后,用 sqlmigrate 指令可以看出新建了 Press 模型表,并在 Book 模型表中,新建了一个外键。

    --
    -- Create model Press
    --
    CREATE TABLE `chart_press` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `name` varchar(50) NOT NULL);
    --
    -- Add field press to book
    --
    ALTER TABLE `chart_book` ADD COLUMN `press_id` integer DEFAULT 1 NOT NULL , ADD CONSTRAINT `chart_book_press_id_3e2ac00a_fk_chart_press_id` FOREIGN KEY (`press_id`) REFERENCES `cha
    rt_press`(`id`);
    ALTER TABLE `chart_book` ALTER COLUMN `press_id` DROP DEFAULT;
    
    

    这里 Book 模型事先已经新建好。

    执行 migrate 指令时,如果抛出 django.db.utils.IntegrityError: (1452, ‘Cannot add or update a child row: a foreign key constraint fails (django.#sql-814_45, CONSTRAINT chart_book_press_id_3e2ac00a_fk_chart_ press_id FOREIGN KEY (press_id) REFERENCES chart_press (id))’) 错误,说明需要建外键的主表还有数据。
    可以清理后,再执行 migrate 指令。

    执行 migrate 指令后,可以看到 book 表已经建好了外键:

    也可以使用以下方法,创建自关联关系:

    models.ForeignKey('self', on_delete=models.CASCADE)
    

    如果需要关联的模型还未定义好,那么可以先定义名称,然后在 ForeignKey 方法中引用该名称,比如上例:

    class Press(models.Model):
        pass
    
    
    class Book(models.Model):
        name = models.CharField('书名', max_length=50, primary_key=True)
        press = models.ForeignKey('Press', on_delete=models.CASCADE,default='1')
    
    

    2 使用方法

    为了让打印更人性化,我们为每个类都重新定义了 __str__ 方法:

    class Press(models.Model):
        ...
    
        def __str__(self):
            return '%s' %(self.name)
    
    
    class Book(models.Model):
       ...
        def __str__(self):
            return '%s' % (self.name)
    
    

    2.1 创建模型时,关联对象

    在 shell 中,创建了一个出版社,并在新建的书模型中做了关联:

    可以在 Book 对象中访问所关联的 Press 对象。

    也可以不执行 save() 保存模型,只要该模型被作为其它模型的外键被引用创建,也会被正常保存:

    press=Press.objects.create(name='上海文艺出版社')
    book=Book.objects.create(name='猫的桌子',press=press)
    

    2.2 在已有模型上,关联对象

    也可以先建立 Press 模型实例,然后再关联多个 Book 模型实例。

    shell 执行情况:

    如果添加错误类型的对象,那么会引发 TypeError!

    2.3 查询

    xx_set 与 X.objects 对象都支持 filter 方法,方法内可以使用双下划线分隔语法,来获取过滤出需要的数据:

    也可以在 filter 方法中,定义多个条件,这些条件将会在 SQL 语句的 where 中以 and 形式连接起来:

    Book.objects.filter(press__name='北京联合出版公司',press__book__pages__gt=1)
    

    运行结果:

    <QuerySet [<Book: 钢琴的重量>]>

    也可以把相关对象,作为参数传入 filter 方法,进行查询:

    还可以使用查询集作为参数传入 filter 方法,进行查询:

    之前是以 Press 对象为条件,查询出对应的 Book 对象的。我们还可以反向查询,即以 Book 对象为条件,查询出对应的 Press 对象:

    因为之前定义的 Book 模型是以 name 作为主键的,所以这里的第一个示例,是以书名作为入参的。

    可以这样查询记录数:

    2.4 级联删除

    因为之前为 Book 模型的 press 字段设置了级联删除,所以如果删除了一个出版社(Press 实例),那么所对应的书(Book 实例),也会被一并删除。

    也可以在 filter 方法之后调用删除方法:

    展开全文
  • 前边我们讲过了单向多对一的关联关系,即在Java代码-hbm.xml配置文件-数据库表格中只是描述了一种类中多个对象可以对应一个其他类对象的关联关系。我们需要在一个类中含有另一个类的引用变量,然后在包含类的hbm.xml...

      前边我们讲过了单向多对一的关联关系,即在Java代码-hbm.xml配置文件-数据库表格中只是描述了一种类中多个对象可以对应一个其他类对象的关联关系。我们需要在一个类中含有另一个类的引用变量,然后在包含类的hbm.xml文件中描述这个属性变量对应的外键和另一张表格中的主键的关联关系,使用<many-to-one>来描述这种关系,然后执行程序就会在数据库中自动生成这种单向一对多的关联关系。

      今天我们来讲一讲基于上面的单向多对一的关联关系来描述另外一种双向一对多的关联关系,即站在一端来看是一对多,站在多的一端来看是多对一,关系维护是双向的

      1.域模型

      和单向多对一的关联关系不同的是,除了在多的一端的Java类中存在一的一端的Java类的引用变量之外,我们还需要在一的一端的Java类中添加一个多的一端的Java类型的集合属性的引用

      需要注意的是:这个集合类型的属性必须是接口类型的,因为通过Hibernate获取的集合类型的对象时Hibernate内置的对象,这个类型的对象实现了集合接口却未继承其他类型的集合实现类,所以我们在赋值的时候才可以赋的上。

      2.关系数据模型

      和单向多对一一样,我们将多的一端的外键指向一的一端的表格的主键。

      3.hbm.xml文件

      多的一端的hbm.xml文件不变,而在一的一端的hbm.xml文件中,我们需要添加一个新的节点来描述从一的一端到多的一端的一对多的关联关系

      <set name="一端包含的多端类型的集合变量名称" table="集合变量类型的对应的表格的名称">

        <key column="对应的多端的外键的名称">

        <one-to-many class="多端的Java类型的名称">

      <set>  

      3.测试双向一对多的关联关系的CURD操作

      ① 保存:

      对于这种双向的关联关系,我们需要在两个类中的hbm.xml文件中进行维护,比较消耗我们的资源,那么我们可不可以只让一个类的hbm.xml来维护这种双向的关联关系呢?当然是可以的,我们选择多的一方来维护这种双向的关联关系,所以只需要在一的一方的hbm.xml文件中的set节点中指定inverse="true"就可以将这种维护双向关联关系的责任反转给多的一方了。这样一来,在保存的时候,我们先插入一的一方的对象,再插入多的一方的对象,就只会执行两条insert语句,而不会出现update语句了

      ② 查询

      先查询一的一方,和单向多对一一样会出现延迟加载的情况,即只有当使用包含的多的一方的对象时才会发送SQL语句进行查询。

      通过一的一方的对象获取的多的一方的集合对象,是Hibernate框架的内置的集合对象,该类型有延迟加载和存放代理对象的功能。

      4.hbm.xml文件中set节点的属性

      ① inverse:反转维护关联关系的对象,我们一般在一的一方即不含主键的一方的hbm.xml文件的set中设置这个属性值为true,从而将这种双向的关联关系反转交给多的一方的hbm.xml文件来单独维护。

      ② cascade:级联属性的设置,我们一般不设置级联属性,而采取手动的方式解除关联关系再进行删除操作。cascade值取delete时,那么我们在删除一的一端时就会将关联的多的一端的数据也全部删去;cascade值取save-update时,那么我们在保存一端的对象时,也会将多的一端的对象一并保存进去。

      ③ order-by:指定我们在获取对象时,按照order-by当中的值来进行排序之后再获取,注意这里边的值应该是SQL语言中的列名或者SQL函数,而不应该是类中的属性名称。

    展开全文
  • 关系:事物之间相互作用、相互联系的状态。...映射:这里指java对象和数据库表的种对应关系。动词:形成这种对应关系。 级联:有关系的双方中操作一方,另一方也将采取一些动作。 关联的联系种类

    关系:事物之间相互作用、相互联系的状态。范围最大。

    联系:在关系数据库中表示实体与实体之间的联系,1:1,1:n,m:n。

    关联:表示对象之间的关系,既有数量性,又有方向性;动词:将对象之间通过某种方式联系起来。

    映射:这里指java对象和数据库表的一种对应关系。动词:形成这种对应关系。

    级联:有关系的双方中操作一方,另一方也将采取一些动作。

    关联的联系种类

    在不考虑关联的方向前提下,联系就是关系数据库中表示实体与实体之间的联系,1:1,1:n,m:n。

    一对一联系(1:1):如用户和身份证、一夫一妻

    一对多联系(1:n):如班级和学生

    多对多联系(m:n):如学生和选课

    关联的方向

    关联关系的方向可分为单向关联和双向关联。

    双向关联的方向其实就不重要了,因为通过任一一方都可以维护彼此的关系。也就是说:在双向关联中一对多和多对一都是一样的。

    利用Java Project项目演示试用Hibernate技术添加数据到数据库


    1 建立项目之后首先呢肯定是需要导入相关的JAR包的

    2 然后是创建实体类

     

    复制代码
    package cn.itcast.hiberate.sh.domain;
    
    public class Student {
        private Long sid;
        private String sname;
        private String description;
        public Long getSid() {
            return sid;
        }
        public void setSid(Long sid) {
            this.sid = sid;
        }
        public String getSname() {
            return sname;
        }
        public void setSname(String sname) {
            this.sname = sname;
        }
        public String getDescription() {
            return description;
        }
        public void setDescription(String description) {
            this.description = description;
        }
        @Override
        public String toString() {
            return "Student [sid=" + sid + ", sname=" + sname + ", description="
                    + description + "]";
        }
        
    }
    复制代码

     

    复制代码
    package cn.itcast.hiberate.sh.domain;
    
    import java.util.Set;
    
    public class Classes {
        private Long cid;
        private String cname;
        private String description;
        private Set<Student> students;
        public Long getCid() {
            return cid;
        }
        public void setCid(Long cid) {
            this.cid = cid;
        }
        public String getCname() {
            return cname;
        }
        public void setCname(String cname) {
            this.cname = cname;
        }
        public String getDescription() {
            return description;
        }
        public void setDescription(String description) {
            this.description = description;
        }
        public Set<Student> getStudents() {
            return students;
        }
        @Override
        public String toString() {
            return "Classes [cid=" + cid + ", cname=" + cname + ", description="
                    + description + ", students=" + students + "]";
        }
        public void setStudents(Set<Student> students) {
            this.students = students;
        }
        
    }
    复制代码

    Student映射文件

    复制代码
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping>
        <!-- name的值代表的是一个实体 -->
        <class name="cn.itcast.hiberate.sh.domain.Student">
            <!-- id用于指定主键  column,主键在数据库表列 ,  increment,主键自增 -->
            <!-- length,指定长度 type,类型,也可以不写 -->
            <id name="sid" length="5" type="java.lang.Long">
                <generator class="increment"></generator>
            </id>
            <!-- 表示表中普通的属性 -->
            <property name="sname" length="20" type="java.lang.String"></property>
            <property name="description" length="100" type="java.lang.String"></property>
        </class>
    </hibernate-mapping>
    复制代码

    Class映射文件

    复制代码
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping>
        <!-- name的值代表的是一个实体 -->
        <class name="cn.itcast.hiberate.sh.domain.Classes">
            <!-- id用于指定主键  column,主键在数据库表列 ,  increment,主键自增 -->
            <!-- length,指定长度 type,类型,也可以不写 -->
            <id name="cid" length="5" type="java.lang.Long">
                <generator class="increment"></generator>
            </id>
            <!-- 表示表中普通的属性 -->
            <property name="cname" length="20" type="java.lang.String"></property>
            <property name="description" length="100" type="java.lang.String"></property>
            <!-- set元素和实体类中的 private Set<Student> students; 相对应 -->
            <!-- 
                set元素对应类中的set集合
                通过set元素使classes表与student表建立关联
                   key是通过外键的形式让两张表建立关联
                   one-to-many是通过类的形式让两个类建立关联
                
                cascade 级联
                   save-update
                       1、当 保存班级的时候,对学生进行怎么样的操作
                            如果学生对象在数据库中没有对应的值,这个时候会执行save操作
                            如果学生对象在数据库中有对应的值,这个时候会执行update操作
                   delete
                   all
                inverse  维护关系
                   true      不维护关系     
                   false     维护关系
                   default   false
             -->
            <set name="students" cascade="save-update">
                <!-- 
                    key是用来描述外键
                 -->
                <key column="cid"></key>
                <one-to-many class="cn.itcast.hiberate.sh.domain.Student"/>
            </set>
        </class>
    </hibernate-mapping>
    复制代码

    3 然后是配置文件 hibernate.cfg.xml

    复制代码
    <?xml version='1.0' encoding='utf-8'?>
    <!DOCTYPE hibernate-configuration PUBLIC
            "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
            "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
    <hibernate-configuration>
        <!-- 
            一个session-factory只能连接一个数据库
        -->
    <session-factory>
        <!-- 
            数据库的用户名
        -->
        <property name="connection.username">root</property>
        <!-- 
            密码
        -->
        <property name="connection.password">root</property>
        <!-- 
            url
        -->
        <property name="connection.url">
            jdbc:mysql://localhost:3306/itcast_sh_hibernate
        </property>
        <!-- 
            作用:根据持久化类和映射文件生成表
            validate
            create-drop
            create
            update
        -->
        <property name="hbm2ddl.auto">update</property>
        <!-- 
            显示hibernate内部生成的sql语句
        -->
        <property name="show_sql">true</property>
        <mapping resource="cn/itcast/hiberate/sh/domain/Classes.hbm.xml" />
        <mapping resource="cn/itcast/hiberate/sh/domain/Student.hbm.xml" />
    
    </session-factory>
    </hibernate-configuration>
    复制代码

    4 hibernate创建 sessionfactory 的工具类

    复制代码
    package cn.itcast.hibernate.sh.utils;
    
    import org.hibernate.SessionFactory;
    import org.hibernate.cfg.Configuration;
    import org.junit.Before;
    
    public class HibernateUtils {
        public static SessionFactory sessionFactory;
        public static String url;
        // 需要在加载的时候就进行配置
        @Before
        public void init(){
            // 创建 Configuration 对象
            Configuration configuration = new Configuration();
            // 加载配置文件
            configuration.configure(url);
            sessionFactory = configuration.buildSessionFactory();
        }
    }
    复制代码

    5 测试类   需要注意的是,hibernate 可以创建相对应的表,但是 数据库需要自己先创建好

    复制代码
    package cn.itcast.hibernate.sh.test;
    
    import java.util.HashSet;
    import java.util.Set;
    
    import org.hibernate.Session;
    import org.hibernate.Transaction;
    import org.junit.Test;
    
    import cn.itcast.hiberate.sh.domain.Classes;
    import cn.itcast.hiberate.sh.domain.Student;
    import cn.itcast.hibernate.sh.utils.HibernateUtils;
    
    public class TestOneToMany extends HibernateUtils{
        static{
            url="/hibernate.cfg.xml";
        }
        // 建表
        @Test
        public void  testCreateTable(){
            
        }
        // 创建一个班级
        /**
         * Hibernate: select max(cid) from Classes
           Hibernate: insert into Classes (cname, description, cid) values (?, ?, ?)
         */
        @Test
        public void save_classes(){
            Session session = sessionFactory.openSession();
            // 除了查询之外的操作都需要使用事务
            Transaction transaction = session.beginTransaction();
            Classes classes = new Classes();
            classes.setCname("峡谷1");
            classes.setDescription("召唤师峡谷");
            session.save(classes);     // 将临时状态的对象转换成持久化状态
            transaction.commit();
            session.close();
        }
        // 创建一个学生
        /**
         * Hibernate: select max(sid) from Student
           Hibernate: insert into Student (sname, description, sid) values (?, ?, ?)
         */
        @Test
        public void save_student(){
            // session 的实质可以看为一个数据库连接
            Session session = sessionFactory.openSession();
            Transaction transaction = session.beginTransaction();
            Student student = new Student();
            student.setSname("黑铁");
            student.setDescription("菜");
            session.save(student);
            transaction.commit();
            session.close();
        }
        // 创建一个班级的时候同事创建一个学生,级联同时维护关系所以student表的外键也有值了
        /**
         *  Hibernate: select max(cid) from Classes
            Hibernate: select max(sid) from Student
            Hibernate: insert into Classes (cname, description, cid) values (?, ?, ?)
            Hibernate: insert into Student (sname, description, sid) values (?, ?, ?)
            Hibernate: update Student set cid=? where sid=?
         */
        @Test
        public void saveClasses_cacade_saveStudent(){
            Session session = sessionFactory.openSession();
            Transaction transaction = session.beginTransaction();
            Classes classes = new Classes();
            classes.setCname("峡谷2");
            classes.setDescription("召唤师峡谷2");
            Student student = new Student();
            student.setSname("白银呢");
            student.setDescription("还是菜");
            Set<Student> students = new HashSet<Student>();
            students.add(student);
            classes.setStudents(students);
            session.save(classes);
            transaction.commit();
            session.close();
        }
        // 存在一个班级,新建一个学生
        /**
         *  Hibernate: select classes0_.cid as cid0_0_, classes0_.cname as cname0_0_, 
         *  classes0_.description as descript3_0_0_ from Classes classes0_ where classes0_.cid=?
            Hibernate: select students0_.cid as cid0_1_, students0_.sid as sid1_, 
            students0_.sid as sid1_0_, students0_.sname as sname1_0_, students0_.description as descript3_1_0_ from Student students0_ where students0_.cid=?
            Hibernate: select max(sid) from Student
            Hibernate: insert into Student (sname, description, sid) values (?, ?, ?)
            Hibernate: update Student set cid=? where sid=?
         */
        @Test
        public void test_classes_saveStudent(){
            Session session = sessionFactory.openSession();
            Transaction transaction = session.beginTransaction();
            Classes classes = (Classes) session.get(Classes.class, 4L);
            Student student = new Student();
            student.setSname("白白");
            student.setDescription("有点菜");
            // classes 是持久化状态 可以直接添加
            classes.getStudents().add(student);
            session.save(classes);
            transaction.commit();
            session.close();
        }
        // 存在一个学生,新建一个班级
        /**
         *  Hibernate: select student0_.sid as sid1_0_, student0_.sname as sname1_0_, 
         *  student0_.description as descript3_1_0_ from Student student0_ where student0_.sid=?
            Hibernate: select max(cid) from Classes
            Hibernate: insert into Classes (cname, description, cid) values (?, ?, ?)
            Hibernate: update Student set cid=? where sid=?
         */
        @Test
        public void test_student_saveClasses(){
            Session session = sessionFactory.openSession();
            Transaction transaction = session.beginTransaction();
            Student student = (Student) session.get(Student.class, 1L);
            Classes classes = new Classes();
            classes.setCname("峡谷3");
            classes.setDescription("召唤师峡谷3");
            Set<Student> students = new HashSet<Student>();
            students.add(student);
            classes.setStudents(students);
            // 临时状态的 classes 需要 save
            session.save(classes);
            transaction.commit();
            session.close();
        }
        // 存在一个 班级和学生 ,将其建立连接
        /**
         *  Hibernate: select classes0_.cid as cid0_0_, classes0_.cname as cname0_0_, 
         *  classes0_.description as descript3_0_0_ from Classes classes0_ where classes0_.cid=?
            Hibernate: select student0_.sid as sid1_0_, student0_.sname as sname1_0_, 
            student0_.description as descript3_1_0_ from Student student0_ where student0_.sid=?
            Hibernate: select students0_.cid as cid0_1_, students0_.sid as sid1_, students0_.sid as sid1_0_,
             students0_.sname as sname1_0_, students0_.description as descript3_1_0_ 
             from Student students0_ where students0_.cid=?
            Hibernate: update Student set cid=? where sid=?
    
         */
        @Test
        public void updateClasses_cascade_updateStudent(){
            Session session = sessionFactory.openSession();
            Transaction transaction = session.beginTransaction();
            Classes classes = (Classes) session.get(Classes.class, 2L);
            Student student = (Student) session.get(Student.class, 5L);
            classes.getStudents().add(student);
            transaction.commit();
            session.close();
        }
        // 把一个学生从一个班级解除关系
        /**
         *  Hibernate: select classes0_.cid as cid0_0_, classes0_.cname as cname0_0_, 
         *  classes0_.description as descript3_0_0_ from Classes classes0_ where classes0_.cid=?
            Hibernate: select students0_.cid as cid0_1_, students0_.sid as sid1_, 
            students0_.sid as sid1_0_, students0_.sname as sname1_0_, students0_.description
             as descript3_1_0_ from Student students0_ where students0_.cid=?
            Hibernate: update Student set cid=null where cid=? and sid=?
         */
        @Test
        public void test_release(){
            Session session = sessionFactory.openSession();
            Transaction transaction = session.beginTransaction();
            Classes classes = (Classes) session.get(Classes.class, 2L);
            Set<Student> students = classes.getStudents();
            for(Student s : students){
                if(s.getSid() == 5){
                    students.remove(s);
                }
            }
            // 解除了学生5的关系
            transaction.commit();
            session.close();
        }
        // 解除一个班级下面的一些学生的关系
        @Test
        public void test_releaseR(){
            Session session = sessionFactory.openSession();
            Transaction transaction = session.beginTransaction();
            Classes classes = (Classes) session.get(Classes.class, 2L);
            Set<Student> students = classes.getStudents();
            for(Student s : students){
                
                    students.remove(s);
                
            }
            // 解除了班级2下面的关系
            transaction.commit();
            session.close();
        }
        // 删除学生
        /**
         * Hibernate: select student0_.sid as sid1_0_, student0_.sname as sname1_0_, 
         * student0_.description as descript3_1_0_ from Student student0_ where student0_.sid=?
           Hibernate: delete from Student where sid=?
         */
        @Test
        public void testDelete(){
            Session session = sessionFactory.openSession();
            Transaction transaction = session.beginTransaction();
            Student student = (Student) session.get(Student.class, 5L);
            session.delete(student);
            transaction.commit();
            session.close();
        }
        // 删除班级
        /**
         *  Hibernate: select classes0_.cid as cid0_0_, classes0_.cname as cname0_0_, classes0_.description as descript3_0_0_ from Classes classes0_ where classes0_.cid=?
            Hibernate: update Student set cid=null where cid=?
            Hibernate: delete from Classes where cid=?
            删除班级的同时级联删除了 学生表中相应的外键
         */
        @Test
        public void test_deleteClasses(){
            Session session = sessionFactory.openSession();
            Transaction transaction = session.beginTransaction();
            Classes classes = (Classes) session.get(Classes.class, 5L);
            session.delete(classes);
            transaction.commit();
            session.close();
        }
    }
    复制代码
    展开全文
  • 多对关系的处理办法

    千次阅读 2017-03-31 19:41:09
    这时就需要通过建立个第三方关联表,将多对关系拆分成两个对多关系.其中关联表为多方.实例如下:背景 种菜品属于个菜系,个菜系也包括很多菜品; 种菜品根据原材料分可以分为多个种类,如番茄炒蛋可以归为...

    多对多关系的处理

    在数据库设计的过程中,经常会遇到两张表是多对多的关系.
    如订单和商品之间的关系:一个订单包含了很多商品,而一种商品同时也可能属于多个订单.
    这时就需要通过建立一个第三方关联表,将多对多关系拆分成两个一对多关系.其中关联表为多方.

    实例如下:

    背景

    • 一种菜品属于一个菜系,一个菜系也包括很多菜品;
    • 一种菜品根据原材料分可以分为多个种类,如番茄炒蛋可以归为蛋类也可归为蔬菜类,而每个种类下也有多个菜品
    • 通过建立菜系-菜品关联表,种类-菜品关联表来处理菜品与菜系,菜品与种类之间的多对多关系
    • 数据表名词解释:
      1. food:菜品
      2. foodstyle:菜系
      3. foodtype:种类
      4. stylelink:菜系-菜品关联表
      5. typelink:种类-菜品关联表

    对应的ER图如下:

    展开全文
  • 实际的开发中,对数据库的操作常常会涉及到多张表,这在...在关系型数据库中,多表之间存在着三种关联关系,分别为一对一、一对多和多对多 一对一:在任意一方引入对方主键作为外键; 一对多:在“多”的一方,...
  • n-n(多对多)的关联关系必须通过连接表实现。下面以商品种类和商品之间的关系,即个商品种类下面可以有多种商品,种商品又可以属于多个商品种类,分别介绍单向的n-n关联关系和双向的n-n关联关系。单向的n-n关联...
  • echarts多对关系

    2020-07-29 10:28:25
    category: 0, // 这是种类级实体1二级关系2三级关系3四级关系4 symbolSize: 50, draggable: true, fixed: true, value: [0, 150] }, { name: "威马汽车", category: 0, symbolSize: 80, draggable: ...
  • 种类Sort与勘误Errata是一对多关系. Sort.java package com.daacc.dao.sort; import java.util.HashSet; import java.util.Set; import com.daacc.dao.teacher.Teacher; public class Sort implements java.io....
  • 类A 和 类B 具有[b]一对多[/b]的关系。A有子类 A1 和 A2,且A1和A2的字段个数和种类相差较大。 系统A的检索/查找要求较低,B的检索/查找功能较也较重要。 表设计如下: A采用TABLE_PER_CLASS的方式[b],...
  • JPA:映射双向多对多关联关系

    千次阅读 2018-11-21 16:38:19
    在双向多对关系中,我们必须指定关系维护端(owner side),可以通过@ManyToMany注释中指定 mappedBy属性来标识其为关系维护端 1.这里用商品(Item)和类别(Category)举例子,个商品可以对应多个种类,而种类...
  • n-n(多对多)的关联关系必须通过连接表实现。下面以商品种类和商品之间的关系,即个商品种类下面可以有多种商品,种商品又可以属于多个商品种类,分别介绍单向的n-n关联关系和双向的n-n关联关系。 单向的n-n...
  • 适用场景: ...以上图举例的表来说,一对一关系就是:一个商品对应一个商品种类。所以我们创建实体类的时候,可以这么创建: public class Goods { private int id; private int imgId; priva...
  • 关联关系-种类

    2010-11-17 09:26:54
    1.一对一  单向(主键,外键)  双向(主键,外键)  中间表(不重要)   2.一对多  单向  双向 ----|   ...3.多对一  单向  双向 ----|   4.多对多  单向  双向...
  • 实际的开发中,对数据库的操作常常会涉及到多张表,这在...在关系型数据库中,多表之间存在着三种关联关系,分别为一对一、一对多和多对多 一对一:在任意一方引入对方主键作为外键; 一对多:在“多”的一方,...
  • 商品表设计-实现侧滑栏类目Catagory和商品的多对关系 需求描述 手机端展示店铺或商城类页面 —— 一般有个左边侧滑栏(slidebar),一般为类目,也可以称为种类。右边为商品的详情展示。如下图: 那么现在有个问题,...
  • 在数据库中比较常见一对一、一对的数据,本文将叙述如何用多种方式实现这些关联关系,并对这些方法进行比对和分析。  例子假设的场景如下:  有两张表:product(产品)、category(种类),一个产品只属于某...
  • 1.1 一对多关系 个表中的天数据对应另个表中的条数据,比如: 客户和订单:个客户可以有张订单 分类和商品:种类对应多种商品 部门和员工:个部门里有名员工 … 建表原则:在“”的一方...
  • 数据库种类

    千次阅读 2018-04-25 16:46:28
    关系型数据库中,数据的操作几乎全部建立在个或关系表格上,通过这些关联的表格分类、合并、连接或选取等运算来实现数据库的管理。典型产品:Mysql、Oracle、DB2、Sqlserver二、非关系型数据库(1)键值...
  • ​ 技术真的是日新月异,...​ 真正业务开发中,绝对不是拍脑袋定下来使用那种数据库就使用那种数据库的,选择某种或者某几种数据库配合使用,一定是改数据库有个比较全面的认识。 ​ 关系型数据警告过这么多年的
  • 1:关系型数据库是由张能互相联接的二维行列表格组成的数据库 2:提供SQL的支持,可以实现复杂的查询 3:支持事务处理,能保持数据一致性,ACID理论 (最大优势) 4:只支持存储基础类型 5:海量数据的读写...
  • 3. 多对多 建表原则: 创建一张第三方表, 这张表至少有两个字段, 分别作为外键, 指向另外两张表的主键 例如: 老师和学生, 学生和课程 拆表之后 从表(商品种类数据来源于主表) 商品编号pid 商品名称pname ...
  • 1.hibernate 的缓存用来 存在session连接池和数据库之间,缓存访问速度快·,提高效率,不需要频繁的去访问数据,可以大大降低对... hibernate表的关系有:一对多/多对一、多对多。 2.1 一对多: 例如客户对应订单
  • 这种关系比较简单是一对一关系:  继承是指 一个子类有两个或以上直接父类时称这个继承关系继承。这种继承方式使一个子类可以继承个父类的特性。继承可以看作是单继承的扩展。派生类具有个基类,...
  • 线程之间是一个调用另一个的关系,这种情况主要是处理分支情况, 监视或对一件事的反复执行(如,收到信号后做不同的处理等),这种关系主要是由于信号控制,而且信号特别频繁3.线程之间是同步的关系,就是说两个线程是相互...
  • 在一些场合里面,我们需要一些记录进行颜色标注处理,以标记记录的信息重要性或者进行类别区分,如在客户关系管理系统里面,我们需要...在个CRM客户关系管理系统里面,客户信息的种类比较,用来标记不同类别...
  • SpringBoot学习笔记—Day02 1. spring boot 的配置文件 spring boot使用个全局的配置文件,默认支持俩种类型的配置文件,...以空格的缩进来控制层级关系,左对齐的列数据都是同层级的,另外属性和值也是大小写敏感
  • 数据结构种类

    2017-09-05 15:30:00
    线性关系:一对一关系 树形结构:层次一对多关系 图形结构:复杂的树形结构,如同人际关系网 ———————————————————— 存储结构:顺序存储 和 链式存储 在内存中的存储中,顺序是按照物理...

空空如也

空空如也

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

关系种类多对一