精华内容
下载资源
问答
  • Mysql多对多关系利用中间表查询

    万次阅读 2019-05-25 17:24:17
    1、多对多关系,我们举个简单的例子,一个顾客可以买多件商品,同时一类商品(指多件相同的商品)也可以也可以让多个用户购买 下面是对应的,用户,商品以及关系,其中关系中userId、metId的外键分别是...

    1、多对多关系,我们举个简单的例子,一个顾客可以买多件商品,同时一类商品(指多件相同的商品)也可以也可以让多个用户购买

    下面是对应的表,用户表,商品表以及关系表,其中关系表中userId、metId的外键分别是userTable 的userId 、materialTable 的matId

            userTable                                                      materialTable                                       

     

                                   

       materil_user 

     

    如果我们要查询用户a1买了哪些商品我们可以这样

    SELECT user.userName,user.userId,mat.matName,mat.matId FROM materil_user mu LEFT JOIN userTable user on 
    user.userId=mu.userId LEFT JOIN materialTable mat on mat.matId=mu.matId WHERE mu.userId=1

     查询结果:

    展开全文
  • sql 多对多中间表查询

    2020-04-07 14:56:04
    //查询操作 select stu.name,cou.kecheng from student_course as sc left join student as stu on stu.id=sc.student_id left join course as cou on cou.id=sc.course_id where stu.name="tom";
    /*
     Navicat Premium Data Transfer
    
     Source Server         : node
     Source Server Type    : MySQL
     Source Server Version : 50553
     Source Host           : localhost:3306
     Source Schema         : test
    
     Target Server Type    : MySQL
     Target Server Version : 50553
     File Encoding         : 65001
    
     Date: 07/04/2020 14:54:45
    */
    
    SET NAMES utf8mb4;
    SET FOREIGN_KEY_CHECKS = 0;
    
    -- ----------------------------
    -- Table structure for course
    -- ----------------------------
    DROP TABLE IF EXISTS `course`;
    CREATE TABLE `course`  (
      `id` int(11) UNSIGNED NOT NULL AUTO_INCREMENT,
      `kecheng` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE = MyISAM AUTO_INCREMENT = 4 CHARACTER SET = latin1 COLLATE = latin1_swedish_ci ROW_FORMAT = Dynamic;
    
    -- ----------------------------
    -- Records of course
    -- ----------------------------
    INSERT INTO `course` VALUES (1, '体育');
    INSERT INTO `course` VALUES (2, '语文');
    INSERT INTO `course` VALUES (3, '数学');
    
    -- ----------------------------
    -- Table structure for student
    -- ----------------------------
    DROP TABLE IF EXISTS `student`;
    CREATE TABLE `student`  (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `name` char(10) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE = MyISAM AUTO_INCREMENT = 10 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Fixed;
    
    -- ----------------------------
    -- Records of student
    -- ----------------------------
    INSERT INTO `student` VALUES (1, 'tom');
    INSERT INTO `student` VALUES (2, 'jerry');
    INSERT INTO `student` VALUES (5, '张三');
    INSERT INTO `student` VALUES (6, '李四');
    INSERT INTO `student` VALUES (7, '王五');
    INSERT INTO `student` VALUES (8, '张五');
    INSERT INTO `student` VALUES (9, '李三');
    
    -- ----------------------------
    -- Table structure for student_course
    -- ----------------------------
    DROP TABLE IF EXISTS `student_course`;
    CREATE TABLE `student_course`  (
      `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT,
      `course_id` int(11) NULL DEFAULT NULL,
      `student_id` int(11) NULL DEFAULT NULL,
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE = MyISAM AUTO_INCREMENT = 10 CHARACTER SET = latin1 COLLATE = latin1_swedish_ci ROW_FORMAT = Fixed;
    
    -- ----------------------------
    -- Records of student_course
    -- ----------------------------
    INSERT INTO `student_course` VALUES (1, 1, 1);
    INSERT INTO `student_course` VALUES (2, 1, 2);
    INSERT INTO `student_course` VALUES (3, 1, 3);
    INSERT INTO `student_course` VALUES (4, 1, 4);
    INSERT INTO `student_course` VALUES (5, 2, 1);
    INSERT INTO `student_course` VALUES (6, 2, 2);
    INSERT INTO `student_course` VALUES (7, 2, 3);
    INSERT INTO `student_course` VALUES (8, 3, 1);
    INSERT INTO `student_course` VALUES (9, 3, 2);
    
    SET FOREIGN_KEY_CHECKS = 1;
    
    
    //查询操作
    select stu.name,cou.kecheng from student_course as sc left join student as stu on stu.id=sc.student_id left join course as cou on cou.id=sc.course_id where stu.name="tom";
    

    展开全文
  • ORACLE 查询中间表的创建

    千次阅读 2021-02-26 15:34:08
    ORACLE 多表查询中间表的创建 表与表之间关系的分类: 1. 一对一(了解): * 如:人和身份证 * 分析:一个人只有一个身份证,一个身份证只能对应一个人 2. 一对多(多对一): * 如:部门和员工 * 分析...

    ORACLE 多表查询中间表的创建

    表与表之间关系的分类:

    		1. 一对一(了解):
    			* 如:人和身份证
    			* 分析:一个人只有一个身份证,一个身份证只能对应一个人
    		2. 一对多(多对一):
    			* 如:部门和员工
    			* 分析:一个部门有多个员工,一个员工只能对应一个部门
    		3. 多对多:
    			* 如:学生和课程
    			* 分析:一个学生可以选择很多门课程,一个课程也可以被很多学生选择
    

    具体的实现方式:

    		1. 一对多(多对一):
    			* 如:部门和员工
    			* 实现方式:在多的一方建立外键,指向一的一方的主键。
    		
    		2. 多对多(重点):
    			* 如:学生和课程
    			* 实现方式:多对多关系实现需要借助第三张中间表。中间表至少包含两个字段,这两个字段作为第三张表的外键,分别指向两张表的主键
    		
    		3. 一对一(了解):
    			* 如:人和身份证 
    			* 实现方式:一对一关系实现,可以在任意一方添加唯一外键指向另一方的主键。
    

    详细并且典型的实例如下

    用户表 USER

    CREATE TABLE USER(
    id VARCHAR(32)  PRIMARY KEY,
    email VARCHAR(50) UNIQUE NOT NULL,
    username VARCHAR(50),
    PASSWORD VARCHAR(50)
    
    )
    INSERT INTO USER(id,email,username,PASSWORD)VALUE('1','111','小明','11111')
    INSERT INTO USER(id,email,username,PASSWORD)VALUE('2','222','小红','22222')
    INSERT INTO USER(id,email,username,PASSWORD)VALUE('3','333','小张','33333')
    

    查询到的结果为
    用户表详情

    角色表 ROLE

    CREATE TABLE role(
    id VARCHAR(32)  PRIMARY KEY,
    roleName VARCHAR(50) ,
    roleDesc VARCHAR(50)
    )
    
    INSERT INTO role(id,roleName,roleDesc)VALUE('1','工程师','111')
    INSERT INTO role(id,roleName,roleDesc)VALUE('2','医生','222')
    INSERT INTO role(id,roleName,roleDesc)VALUE('3','教师','333')
    
    

    查询到的结果为
    角色表详情

    中间表

    CREATE TABLE users_role(
    userId VARCHAR(32),
    roleId VARCHAR(32),
    PRIMARY KEY(userId,roleId),
    FOREIGN KEY (userId) REFERENCES users(id),
    FOREIGN KEY (roleId) REFERENCES role(id)
    )
    
    INSERT INTO users_role(userId,roleId )VALUE('1','2')
    INSERT INTO users_role(userId,roleId )VALUE('2','2')
    INSERT INTO users_role(userId,roleId )VALUE('3','3')
    

    查询到的结果为
    中间表详情

    关联中间表进行查询

    重点特别要注意此SQL的写法

    查询的结果会以中间表的id为基准(一定要理解)

    --查询的结果会以中间表的id为基准
    SELECT * FROM users a ,role b, users_role c WHERE a.id=c.userid AND b.id=c.roleid
    

    查询到的结果为:
    进行表的多对多查询的结果

    展开全文
  • jpa多对多+中间表查询,删除,添加 实体类数据库如下: 表单类 资产类 中间表:为双主键模式,head_id为表单

    jpa多对多+中间表的查询,删除,添加操作

    实体类数据库如下:

    表单类
    在这里插入图片描述

    资产类
    在这里插入图片描述

    中间表:为双主键模式,head_id为表单
    在这里插入图片描述

    实体类(维护方)如下:

    @Entity
    @Table(name="t_amc_asset_head")
    @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
    public class AssetHead extends BaseEntity {
    
        private static final long serialVersionUID = 1L;
    
        @Temporal(TemporalType.DATE)
        @DateTimeFormat( pattern = "yyyy-MM-dd")
        @Column(name = "head_time")
        Date headTime;//领用时间
    
        @ManyToOne
        @JoinColumn(name = "user_id")
        private UserInCompany userInCompany;//关联  ?
    
        @Column(name = "user_name")
        String UserName;//领用人
    
    
        @Column(name = "head_position")
        String headPosition;//领用位置
    
        @Column(name = "head_ps")
        String headPS;//领用备注
    
    
        @Column(name = "head_status")
        String headStatus;//领用状态   0:new   1 :锁定
    
        @Column(name = "label_id")
        String labelId;//资产编号
    
        @Column(name = "asset_name")
        String assetName;//资产名称
    
    
    //多对多
        @ManyToMany(fetch=FetchType.EAGER)
        @JoinTable(name = "middle_asset_head", joinColumns = { @JoinColumn(name = "head_id") }, inverseJoinColumns = { @JoinColumn(name = "label_id") })
        /* 加载策略定义 */
        @Fetch(FetchMode.SUBSELECT)
        /* 缓存策略 */
        @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
        private List<Asset> assetList;
    
    

    collection 增删查如下:

    新增

    
        /**
         * 新建需要在状态未使用的资产才可以执行操作
         *
         * @param assethead
         *
         * @return
         */
        @RequestMapping(value = "save", method = RequestMethod.POST)
        @ResponseBody
        public AjaxMessage save(@RequestParam("assethead")String assethead,@RequestParam("ids[]")String ids[]) throws ParseException {
    
       
              //添加领用单
              String bb=assetHead.get("headTime").toString();
               SimpleDateFormat  sdf = new SimpleDateFormat("yyyy-MM-dd");
               Date date = sdf.parse(bb);
    
              AssetHead assetHead1=new AssetHead();
              assetHead1.setUserInCompany(userInCompanyService.findOne((String)assetHead.get("userInCompany.tid")));
              assetHead1.setUserName((String)assetHead.get("userName"));
              assetHead1.setHeadPS((String)assetHead.get("headPS"));
              assetHead1.setHeadPosition((String)assetHead.get("headPosition"));
              assetHead1.setHeadTime(date);
              assetHead1.setHeadStatus("0");
              assetHeadService.save(assetHead1);//添加到领用单
    
    
    
            List<Asset> assetList=new ArrayList<Asset>();
            for (int i = 0;i < ids.length; i++) {//
    
                Asset asset=new Asset();
                asset=assetService.findOne(splits[i]);
                asset.setUseStatus("locking");
                assetService.save(asset);
                assetList.add(asset);
    
    
            }
    
            AssetHead Assethead= assetHeadService.findOne(assetHead1.getTid());//多对多中间表,先获取维护方的对象
            if(Assethead!=null) {//判断对象是否为空
                if(Assethead.getAssetList()==null){
                    Assethead.setAssetList(Lists.newArrayList());
                }
                Assethead.getAssetList().addAll(assetList);//对象不为空,向中间表添加全部记录
            }
           assetHeadService.save(Assethead);//保存中间表操作
    
    
            return AjaxMessage.createSuccessMsg();
        }
    
    /**
         * 删除
         *
         * @param id
         * @return
         */
        //@PreAuthorize("hasRole('ROLE_AssetsourceListDelete')")
        @RequestMapping(value = "delete/{id}", method = RequestMethod.POST)
        @ResponseBody
        public AjaxMessage delete(@PathVariable("id") String id) {
            //解放资产
           AssetHead assetHead=assetHeadService.findOne(id);
            List<Asset> assetList=new ArrayList<Asset>();
            if(assetHead!=null) {
                if(assetHead.getAssetList()==null){
                    assetHead.setAssetList(Lists.newArrayList());
                }
                assetList=assetHead.getAssetList();
            }
            for (Asset asset:assetList) {//对中间表资源全部释放
                asset.setUseStatus("unused");
                System.out.println("!!!!!!!!!!!!!!!!!!!!!对中间表资源全部释放!!!!!!!!!!!!!"+asset);
                assetService.save(asset);
            }
    
    //删除中间表
            assetHead.getAssetList().removeAll(assetHead.getAssetList());
           assetHeadService.save(assetHead);
    
            assetHeadService.deleteByLogic(id);//删除领用单
            return AjaxMessage.createSuccessMsg();
        }
    
    
    
    /**
         * 跳转修改页
         * @param id
         * @param model
         * @return
         */
        @RequestMapping(value = "use/{id}")//领用修改
        public String edit(@PathVariable("id") String id,Model model) {
            model.addAttribute("assethead", assetHeadService.findOne(id));//查询领用单
         AssetHead assetHead= assetHeadService.findOne(id);
    
            List<Asset> assetList=new ArrayList<Asset>();
            if(assetHead!=null) {
                if(assetHead.getAssetList()==null){
                    assetHead.setAssetList(Lists.newArrayList());//通过中间表,查询领用单对应的所有资源单
                }
                assetList=assetHead.getAssetList();
            }
    
            model.addAttribute("assetList",assetList);
            return "amc/assethead/edit";
        }
    

    最后:修改就是将删除和添加结合起来

    展开全文
  • 因为中间表带有属性,采用的多对多映射方式 两个实体类都使用 @OneToMany( mappedBy="workDateTime")   需求:因为中间表使用两个外键作为联合主键 ,如果需要对中间表的属性进行修改, 1、一般做法 ...
  • Mysql 之间的三种关系之间一般存在三种关系,即一对一,一对多,多对多关系。article_cate 文章分类有id,title,state, 字段article 文章有id,title,description,cate_id,state 字段一个分类对应 多...
  • 如有user,role,userrole,3者之间的关系是,user和role通过userrole表多对多关联。   user类:public class user implements java.io.Serializable { private Integer userId; private String ...
  • 利用中间表多对多关联的查询

    千次阅读 2018-06-26 14:13:45
        select stu.stu_NO,stu.name,cou.cou_no,cou.name from s_c sc left join student stu on stu.id=sc.stu_id left join cource cou on cou.id=sc.cour_id where stu.name...
  • 用户表A,小组表B,小组和用户是多对多关系,中间有个中间表M 已知 小组 id 即teamId ,想知道这个小组中的用户列表信息,可以如下写sql: select * from A a where EXISTS (select m.id from M m where a.id = ...
  • 通过一个学生的id查询出该学生所学的所有科目。 使用到的表格: 1.student:学生 2.subject:科目 3.stu_sub:学生-科目(这里的成绩字段没用到,不用管) 实体类( get、set方法省略): 1.student public...
  • 实现多对多中间表的分组+排序查询 设计思想: 模拟应用市场,不同用户分别在市场中下载app,其中app的状态分为上架/下架,当app被下架时不展示,用户无法下载 示例数据库如下: 下载应用记录表 名称: app_download_...
  • 用户:   &lt;?xml version="1.0" encoding="utf-8"?&gt; &lt;!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "...
  • 多对多查询 其实就是 多个 一对多查询 比如 一个人可以拥有多个角色,而一个角色也可以赋给多个人 那么 从单一个体(比如一个人) 来说,其实就是一次一对多查询罢了 因为有多个个体 相当于循环多次我们的一对多查询的...
  • 该例有两个数据表:user和role以及一个用户角色中间表,用户与角色的多对多关系模型如下: 其中:user表: role表: 用户角色中间表user_role: ...需求:进行多对多查询:其实双向的一对多查询。 步骤: ...
  • mybatis 有中间表的一对多关联查询

    千次阅读 2015-02-28 11:24:24
    关于MyBatis resultMap 3个表关联,一张是中间表 假设有3个表 表A 有字段 id,a1,a2,a3其中id为主键, 又有表B 有字段 id,b1,b2,b3其中id为主键, A跟B 直接没有关系,是通过一张关系表C 来进行关联的 C ...
  • JPA多关联多对多查询

    千次阅读 2018-05-15 22:12:13
    JPA多表关联多对多查询 多对多 需求:查询指定OID的用户,同时返回用户对应角色 注意事项 多对多的三个条件 1. 中间表 2. 本实体类对应的表在中间表...//多对多的三个条件: 中间表,本实体类对应的表...
  • 多对多查询就是两个实体类 通过一个中间表 来实现多对多查询 他和一对多有点类似。 <!--多对多查询--> <resultMap id="reMap" type="com.qst.domian.Employee"> <!-- 主键--> <id ...
  • thinkphp 多对多表查询

    2018-06-30 14:34:00
    中间表classes_students 2。使用模型关联查询 新建模型 Classes在里面添加代码 ClassesStudent中间表模型,可以不写什么 Student在里面添加代码 获取student所在的历史班级 $classes=...
  • 行为动作多对多映射 --> < set name ="ykColumns" table ="yk_action_column" order-by ="sort_order asc" > < key column ="ACTION_ID" > key > < many-to-many class =...
  • 多对多的两张表,需要另外一张中间表中间表中包含各自的主键,在中间表中是外键。 mybatis中的多表查询多对多 user表 role表 中间表:user_role 表之间的关系: 工程目录结构: Role.java package domain; ...
  • 最近项目用到中间表,则遇到如何联查映射的问题,之前一直都是一个表头,个明细或者一一这样的关系,没遇到这样的问题,所以趁机找了下资料解决了这个问题。 表结构设计如下: 主表: CREATE TABLE `...
  • 多对多关系中用用户和角色模型来模拟 一个用户可以用多个角色 一个角色可以被多人拥有 角色表: 用户表: 用户与角色的中间表 这里使用另外一种方法resultMap,定义专门的 resultMap 用于映射一对一...
  • 一.jpa多对多__利用一对多实现(推荐) 尽量不要使用@manyToMany,特别是中间表有冗余字段的时候; 最好是在两个主表中加上@oneToMany,从表中加上@manyToOne来配置,加强jpa对中间表的支持度 !!!注意所有主表中的对应关系...
  • 12、多表查询--多对多

    2021-01-23 20:41:43
    1、多对多操作 案例:用户和角色(多对多) ​ 用户: ​ 角色: 分析步骤 ​ 1.明确表关系 ​ 多对多 ​ 2.确定表关系(描述 外键 | 中间表) ​ 中间表 ​ 3.编写实体类,在实体类中描述表关系(包含关系)...
  • 示例:用户和角色  一个用户可以有多... 需要使用中间表中间表中包含各自的主键,在中间表中是外键。  2、建立两个实体类:用户实体类和角色实体类  让用户和角色的实体类能体现出来多对多的关系  ...

空空如也

空空如也

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

多对多查询中间表