精华内容
下载资源
问答
  • 多表关联查询

    2018-06-26 15:32:29
    1.多表关联查询多表关联查询有五种分别是: 1. 交叉连接(数据库底层的实现原理,笛卡尔积现象) cross join: select * from emp cross jion dept;  select * from emp,dept; 2. 外连接(outer join) 分为左外链接和...

    1.多表关联查询

    多表关联查询有五种分别是:

    1. 交叉连接(数据库底层的实现原理,笛卡尔积现象) cross join:
    select * from emp cross jion dept; 
    select * from emp,dept;
    2. 外连接(outer join)
    分为左外链接和右外连接
    左外连接:
    select * from left [outer] join dept on (emp.deptid=dept.id)
    右外连接:
    select * from right [outer] join dept on (emp.deptid=dept.id)

    3. 内连接(inner join)
    select * from emp,dept where emp.deptid=dept.id;
    select * from emp inner join dept on(emp.deptid=dept.id)
    4. 自然连接
    select * from emp natural join dept;
    5. 自连接(自连接的查询效率没有内外连接的效率高)
    外键在约束自身的某个字段
    子查询

    2.表与表的关联关系

    1:1
    1:n
    m:n
    外键约束 外键名称可以不写系统自动生成 不会重复 自己写方面删除
    [constraint] foreign key(外键名称 FK) references 从表(id PK) [on delete restrict/cascade/set null(部门已经解散,员工等待安排) on update restrict]
    已存在的表添加外键
    alter table tName add [constraint] foreign key(外键名称 FK) references 从表 (id PK)
    删除外键
    alter table tName drop [constraint] foreign key(外键名称 FK) references 从 表 (id PK)
    展开全文
  • Spring Data JPA Specification多表关联查询

    万次阅读 2020-10-23 17:17:59
    需求:有一个流量计的设备,流量计有一个所属罐区id,想要通过所属罐区查到所关联的这个罐区的编码以及名称。 1.流量计实体类: 主要是给流量计实体添加了以下属性,通过tank_area_id关联: package ...

    需求:有一个流量计的设备,流量计有一个所属罐区id,想要通过所属罐区查到所关联的这个罐区的编码以及名称。

    1.流量计实体类:

    主要是给流量计实体添加了以下属性,通过tank_area_id关联:
    在这里插入图片描述

    package com.supcon.mare.tankinfo.entity;
    
    import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
    import lombok.Data;
    import org.springframework.data.annotation.CreatedDate;
    import org.springframework.data.annotation.LastModifiedDate;
    import javax.persistence.*;
    import java.io.Serializable;
    import java.util.Date;
    
    /**
     * @author: zhaoxu
     * @date: 2020/9/28 11:21
     * @description: 流量计对象
     */
    @Entity
    @Table(name = "flowmeter_info")
    @JsonIgnoreProperties(ignoreUnknown = true)
    @Data
    public class FlowmeterInfoEntity implements Serializable {
        private static final long serialVersionUID = 1335421266779672060L;
        /**
         * id
         */
        @Id
        @Column(name = "id", nullable = false)
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
    
        /**
         * 流量计编号
         */
        @Column(name = "flowmeter_code", nullable = false, length = 100)
        private String flowmeterCode;
    
        /**
         * 流量计名称
         */
        @Column(name = "flowmeter_name", nullable = false, length = 100)
        private String flowmeterName;
    
        /**
         * 该设备归属于某个罐区内设备
         */
        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(name = "tank_area_id", referencedColumnName = "id",
                foreignKey = @ForeignKey(name = "none", value = ConstraintMode.NO_CONSTRAINT))
        private TankAreaEntity tankArea;
    
        /**
         * 设备当前状态:正常、维护、检修、停用
         */
        @Column(name = "device_status", nullable = false, length = 100)
        private String deviceStatus;
    
        /**
         * 流量计类型:质量流量计、体积流量计等...
         */
        @Column(name = "flowmeter_type", nullable = false, length = 100)
        private String flowmeterType;
    
        /**
         * 设备描述
         */
        @Column(name = "remark", length = 255)
        private String remark;
    
        /**
         * 启停位号
         */
        @Column(name = "switch_tag", length = 100)
        private String switchTag;
    
        /**
         * 流速,位号数据
         */
        @Column(name = "current_speed", length = 100)
        private String currentSpeed;
    
        /**
         * 流速量程上限
         */
        @Column(name = "current_speed_max", length = 100)
        private String currentSpeedMax;
    
        /**
         * 流速量程下限
         */
        @Column(name = "current_speed_min", length = 100)
        private String currentSpeedMin;
    
        /**
         * 累计流量,位号数据
         */
        @Column(name = "cumulative_flow_total", length = 100)
        private String cumulativeFlowTotal;
    
        /**
         * 累计流量量程上限
         */
        @Column(name = "cumulative_flow_max", length = 100)
        private String cumulativeFlowMax;
    
        /**
         * 累计流量量程下限
         */
        @Column(name = "cumulative_flow_min", length = 100)
        private String cumulativeFlowMin;
    
        /**
         * 是否被占用,是/否,默认否
         */
        @Column(name = "occupied", nullable = false)
        private int occupied;
    
        @CreatedDate
        @Column(name = "gmt_create", updatable = false)
        @Temporal(TemporalType.TIMESTAMP)
        private Date gmtCreate;
    
        @LastModifiedDate
        @Column(name = "gmt_modified", insertable = false)
        @Temporal(TemporalType.TIMESTAMP)
        private Date gmtModified;
    
        @Column(name = "valid", columnDefinition = "integer")
        private Integer valid;
    
    }
    

    2.Specification使用:

    主要是通过Join关联另一个表,进行查询:
    在这里插入图片描述

     Specification<FlowmeterInfoEntity> specification = (root, query, cb) -> {
                List<Predicate> predicates = new ArrayList<Predicate>();
    
                //关联查询
                Join<BlindPlateEntity, TankAreaEntity> join =  root.join("tankArea", JoinType.INNER);
    
                //未删除的数据
                predicates.add(cb.equal(root.get(Constants.VALID), 1));
    
                //流量计名称
                if (tableMap.get(Constants.FLOWMETER_NAME) != null) {
                    predicates.add(cb.like(root.get(Constants.FLOWMETER_NAME), "%" + tableMap.get(Constants.FLOWMETER_NAME) + "%"));
                }
    
                //流量计编号
                if (tableMap.get(Constants.FLOWMETER_CODE) != null) {
                    predicates.add(cb.like(root.get(Constants.FLOWMETER_CODE), "%" + tableMap.get(Constants.FLOWMETER_CODE) + "%"));
                }
    
                //罐区编码
                if (tableMap.get(Constants.TANK_AREA_CODE) != null) {
                    predicates.add(cb.like(join.get(Constants.TANK_AREA_CODE), "%" + tableMap.get(Constants.TANK_AREA_CODE)+ "%"));
                }
    
                //流量计类型
                if (tableMap.get(Constants.FLOWMETER_TYPE) != null) {
                    predicates.add(cb.equal(root.get(Constants.FLOWMETER_TYPE), tableMap.get(Constants.FLOWMETER_TYPE)));
                }
    
                //设备状态
                if (tableMap.get(Constants.DEVICE_STATUS) != null) {
                    predicates.add(cb.equal(root.get(Constants.DEVICE_STATUS), tableMap.get(Constants.DEVICE_STATUS)));
                }
    
                //是否占用
                if (tableMap.get(Constants.OCCUPIED) != null) {
                    predicates.add(cb.equal(root.get(Constants.OCCUPIED), tableMap.get(Constants.OCCUPIED)));
                }
                Predicate[] pre = new Predicate[predicates.size()];
                Predicate preAnd = cb.and(predicates.toArray(pre));
                return query.where(preAnd).getRestriction();
            };
    
    展开全文
  • 本文实例讲述了MongoDB多表关联查询操作。分享给大家供大家参考,具体如下: Mongoose的多表关联查询 首先,我们回忆一下,MySQL多表关联查询的语句: student表: calss表: 通过student的classId关联进行查询...
  • 易语言ACCESS数据库多表关联查询例程.rar 易语言ACCESS数据库多表关联查询例程.rar 易语言ACCESS数据库多表关联查询例程.rar 易语言ACCESS数据库多表关联查询例程.rar 易语言ACCESS数据库多表关联查询例程.rar ...
  • 易语言ACCESS数据库多表关联查询例程源码,ACCESS数据库多表关联查询例程
  • Mybatis的多表关联查询(多对多)

    千次阅读 多人点赞 2021-02-12 23:46:03
    Mybatis的多表关联查询(多对多)项目目录结构实现 Role 到 User 多对多业务要求用户与角色的关系模型编写角色实体类编写 Role 持久层接口实现的 SQL 语句编写映射文件测试代码实现 User 到 Role 的多对多业务要求...

    mybatis中的多表查询:
    
    	示例:用户和角色
    		一个用户可以有多个角色
    		一个角色可以赋予多个用户
    	步骤:
    		1、建立两张表:用户表,角色表
    			让用户表和角色表具有多对多的关系。需要使用中间表,中间表中包含各自的主键,在中间表中是外键。
    		2、建立两个实体类:用户实体类和角色实体类
    			让用户和角色的实体类能体现出来多对多的关系
    			各自包含对方一个集合引用
    		3、建立两个配置文件
    			用户的配置文件
    			角色的配置文件
    		4、实现配置:
    			当我们查询用户时,可以同时得到用户所包含的角色信息
    			当我们查询角色时,可以同时得到角色的所赋予的用户信息
    

    项目目录结构

    在这里插入图片描述

    实现 Role 到 User 多对多

    多对多关系其实我们看成是双向的一对多关系。

    业务要求

    需求:
    当我们查询角色时,可以同时得到角色的所赋予的用户信息。
    分析:
    查询角色我们需要用到Role表,但角色分配的用户的信息我们并不能直接找到用户信息,而是要通过中间表(USER_ROLE 表)才能关联到用户信息。

    用户与角色的关系模型

    用户与角色的多对多关系模型如下:
    在这里插入图片描述

    角色表:
    在这里插入图片描述
    用户表:
    在这里插入图片描述
    用户角色中间表:
    在这里插入图片描述

    编写角色实体类

    Role:

    package com.keafmd.domain;
    
    import java.io.Serializable;
    import java.util.List;
    
    /**
     * Keafmd
     *
     * @ClassName: Role
     * @Description: 角色实体类
     * @author: 牛哄哄的柯南
     * @date: 2021-02-12 16:45
     */
    public class Role implements Serializable {
    
        private Integer roleId;
        private String roleName;
        private String roleDesc;
    
        //多对多的关系映射
        private List<User> users;
    
        public List<User> getUsers() {
            return users;
        }
    
        public void setUsers(List<User> users) {
            this.users = users;
        }
    
        public Integer getRoleId() {
            return roleId;
        }
    
        public void setRoleId(Integer roleId) {
            this.roleId = roleId;
        }
    
        public String getRoleName() {
            return roleName;
        }
    
        public void setRoleName(String roleName) {
            this.roleName = roleName;
        }
    
        public String getRoleDesc() {
            return roleDesc;
        }
    
        public void setRoleDesc(String roleDesc) {
            this.roleDesc = roleDesc;
        }
    
        @Override
        public String toString() {
            return "Role{" +
                    "roleId=" + roleId +
                    ", roleName='" + roleName + '\'' +
                    ", roleDesc='" + roleDesc + '\'' +
                    '}';
        }
    }
    

    编写 Role 持久层接口

    IRoleDao:

    package com.keafmd.dao;
    import com.keafmd.domain.Role;
    import java.util.List;
    
    /**
     * Keafmd
     *
     * @ClassName: IRoleDao
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-02-12 19:01
     */
    
    public interface IRoleDao {
    
        /**
         * 查询所有角色
         * @return
         */
        List<Role> findAll();
    
    }
    

    实现的 SQL 语句

    select u.*,r.id as rid ,r.role_name ,r.role_desc from role r  
    left outer join user_role ur on r.id = ur.rid  
    left outer join user u on u.id=ur.uid 
    

    执行结果:
    在这里插入图片描述

    注意:sql语句换行的时候最好在每行的末尾或开头添加空格,这样可以防止合并成一行时发生错误。

    编写映射文件

    IRoleDao.xml:

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.keafmd.dao.IRoleDao">
    
        <!--定义role表的resultmap-->
        <resultMap id="roleMap" type="role">
            <id property="roleId" column="rid"></id>
            <result property="roleName" column="role_name"></result>
            <result property="roleDesc" column="role_desc"></result>
            <collection property="users" ofType="user">
                <id column="id" property="id"></id>
                <result column="username" property="username"></result>
                <result column="address" property="address"></result>
                <result column="sex" property="sex"></result>
                <result column="birthday" property="birthday"></result>
            </collection>
        </resultMap>
    
        <!--查询所有-->
        <select id="findAll" resultMap="roleMap">
            select u.*,r.id as rid ,r.role_name ,r.role_desc from role r
            left outer join user_role ur on r.id = ur.rid
            left outer join user u on u.id=ur.uid
        </select>
    
    </mapper>
    

    测试代码

    RoleTest:

    package com.keafmd.test;
    
    import com.keafmd.dao.IRoleDao;
    import com.keafmd.dao.IUserDao;
    import com.keafmd.domain.Role;
    import com.keafmd.domain.User;
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.junit.After;
    import org.junit.Before;
    import org.junit.Test;
    
    import java.io.InputStream;
    import java.util.List;
    
    /**
     * Keafmd
     *
     * @ClassName: MybatisTest
     * @Description: 测试类,测试crud操作
     * @author: 牛哄哄的柯南
     * @date: 2021-02-08 15:24
     */
    public class RoleTest {
    
        private InputStream in;
        private SqlSession sqlsession;
        private IRoleDao roleDao;
    
        @Before // 用于在测试方法执行前执行
        public void init()throws Exception{
            //1.读取配置文件,生成字节输入流
            in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.创建SqlSessionFactory工厂
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            SqlSessionFactory factory = builder.build(in);
            //3.使用工厂生产SqlSession对象
            sqlsession = factory.openSession(); //里面写个true,下面每次就不用了写 sqlsession.commit(); 了
            //4.使用SqlSession创建Dao接口的代理对象
            roleDao = sqlsession.getMapper(IRoleDao.class);
        }
    
        @After // 用于在测试方法执行后执行
        public void destory() throws Exception{
            //提交事务
            sqlsession.commit();
            //6.释放资源
            sqlsession.close();
            in.close();
        }
    
    
    
        /**
         * 查询所有
         * @throws Exception
         */
        @Test
        public void testFindAll() {
            List<Role> roles = roleDao.findAll();
            for (Role role : roles) {
                System.out.println("--------每个角色的信息---------");
                System.out.println(role);
                System.out.println(role.getUsers());
               
            }
        }
    
    }
    

    运行结果:

    2021-02-13 00:05:47,481 349    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
    2021-02-13 00:05:47,784 652    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 1027007693.
    2021-02-13 00:05:47,784 652    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3d36e4cd]
    2021-02-13 00:05:47,791 659    [           main] DEBUG om.keafmd.dao.IRoleDao.findAll  - ==>  Preparing: select u.*,r.id as rid ,r.role_name ,r.role_desc from role r left outer join user_role ur on r.id = ur.rid left outer join user u on u.id=ur.uid
    2021-02-13 00:05:47,842 710    [           main] DEBUG om.keafmd.dao.IRoleDao.findAll  - ==> Parameters: 
    2021-02-13 00:05:47,869 737    [           main] DEBUG om.keafmd.dao.IRoleDao.findAll  - <==      Total: 4
    --------每个角色的信息---------
    Role{roleId=1, roleName='院长', roleDesc='管理整个学院'}
    [User{id=41, username='老王', sex='男', address='北京', birthday=Tue Feb 27 17:47:08 CST 2018}, User{id=45, username='新一', sex='男', address='北京', birthday=Sun Mar 04 12:04:06 CST 2018}]
    --------每个角色的信息---------
    Role{roleId=2, roleName='总裁', roleDesc='管理整个公司'}
    [User{id=41, username='老王', sex='男', address='北京', birthday=Tue Feb 27 17:47:08 CST 2018}]
    --------每个角色的信息---------
    Role{roleId=3, roleName='校长', roleDesc='管理整个学校'}
    []
    2021-02-13 00:05:47,871 739    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3d36e4cd]
    2021-02-13 00:05:47,872 740    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@3d36e4cd]
    2021-02-13 00:05:47,872 740    [           main] DEBUG source.pooled.PooledDataSource  - Returned connection 1027007693 to pool.
    
    Process finished with exit code 0
    

    实现 User 到 Role 的多对多

    业务要求

    需求:
    当我们查询用户时,可以同时得到用户所包含的角色信息。

    分析:
    相比上面的实现 Role 到 User 多对多,主要变化就是sql语句的变化。

    编写用户实体类

    User:

    package com.keafmd.domain;
    
    import java.io.Serializable;
    import java.util.Date;
    import java.util.List;
    
    /**
     * Keafmd
     *
     * @ClassName: User
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-02-08 15:16
     */
    
    public class User implements Serializable {
        private Integer id;
        private String username;
        private String sex;
        private String address;
        private Date birthday;
    
        //多对多的关系映射,一个用户可以具备多个角色
        private List<Role> roles;
    
        public List<Role> getRoles() {
            return roles;
        }
    
        public void setRoles(List<Role> roles) {
            this.roles = roles;
        }
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public Date getBirthday() {
            return birthday;
        }
    
        public void setBirthday(Date birthday) {
            this.birthday = birthday;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", username='" + username + '\'' +
                    ", sex='" + sex + '\'' +
                    ", address='" + address + '\'' +
                    ", birthday=" + birthday +
                    '}';
        }
    }
    

    编写 User持久层接口

    IUserDao:

    package com.keafmd.dao;
    
    import com.keafmd.domain.User;
    
    import java.util.List;
    
    /**
     * Keafmd
     *
     * @ClassName: IUserDao
     * @Description: 用户的持久层接口
     * @author: 牛哄哄的柯南
     * @date: 2021-02-06 19:29
     */
    
    public interface IUserDao {
        /**
         * 查询所有用户,同时获取到用户下所有账户的信息
         * @return
         */
        List<User> findAll();
    
    }
    

    实现的 SQL 语句

       select u.*,r.id as rid ,r.role_name ,r.role_desc from user u 
       left outer join user_role ur on u.id = ur.uid 
       left outer join role r on r.id=ur.rid 
    

    执行结果:
    在这里插入图片描述

    编写映射文件

    IUserDao.xml:

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.keafmd.dao.IUserDao">
    
        <!--定义User的resultMap-->
        <resultMap id="userMap" type="user">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="address" column="address"></result>
            <result property="sex" column="sex"></result>
            <result property="birthday" column="birthday"></result>
            <!--配置角色集合的映射-->
            <collection property="roles" ofType="role">
                <id property="roleId" column="rid"></id>
                <result property="roleName" column="role_name"></result>
                <result property="roleDesc" column="role_desc"></result>
            </collection>
    
        </resultMap>
    
        <!--配置查询所有-->
        <select id="findAll" resultMap="userMap">
            select u.*,r.id as rid ,r.role_name ,r.role_desc from user u
            left outer join user_role ur on u.id = ur.uid
            left outer join role r on r.id=ur.rid
    
        </select>
    
    </mapper>
    

    测试代码

    UserTest :

    package com.keafmd.test;
    
    import com.keafmd.dao.IUserDao;
    import com.keafmd.domain.User;
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.junit.After;
    import org.junit.Before;
    import org.junit.Test;
    
    import java.io.InputStream;
    import java.util.List;
    
    /**
     * Keafmd
     *
     * @ClassName: MybatisTest
     * @Description: 测试类,测试crud操作
     * @author: 牛哄哄的柯南
     * @date: 2021-02-08 15:24
     */
    public class UserTest {
    
        private InputStream in;
        private SqlSession sqlsession;
        private IUserDao userDao;
    
        @Before // 用于在测试方法执行前执行
        public void init()throws Exception{
            //1.读取配置文件,生成字节输入流
            in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.创建SqlSessionFactory工厂
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            SqlSessionFactory factory = builder.build(in);
            //3.使用工厂生产SqlSession对象
            sqlsession = factory.openSession(); //里面写个true,下面每次就不用了写 sqlsession.commit(); 了
            //4.使用SqlSession创建Dao接口的代理对象
            userDao = sqlsession.getMapper(IUserDao.class);
        }
    
        @After // 用于在测试方法执行后执行
        public void destory() throws Exception{
            //提交事务
            sqlsession.commit();
            //6.释放资源
            sqlsession.close();
            in.close();
        }
    
    
    
        /**
         * 查询所有
         * @throws Exception
         */
        @Test
        public void testFindAll() {
            List<User> users = userDao.findAll();
            for (User user : users) {
                System.out.println("--------每个用户的信息---------");
                System.out.println(user);
                System.out.println(user.getRoles());
            }
        }
    
    }
    

    运行结果:

    2021-02-13 00:17:32,971 422    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
    2021-02-13 00:17:33,275 726    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 1027007693.
    2021-02-13 00:17:33,275 726    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3d36e4cd]
    2021-02-13 00:17:33,280 731    [           main] DEBUG om.keafmd.dao.IUserDao.findAll  - ==>  Preparing: select u.*,r.id as rid ,r.role_name ,r.role_desc from user u left outer join user_role ur on u.id = ur.uid left outer join role r on r.id=ur.rid
    2021-02-13 00:17:33,319 770    [           main] DEBUG om.keafmd.dao.IUserDao.findAll  - ==> Parameters: 
    2021-02-13 00:17:33,343 794    [           main] DEBUG om.keafmd.dao.IUserDao.findAll  - <==      Total: 10
    --------每个用户的信息---------
    User{id=41, username='老王', sex='男', address='北京', birthday=Tue Feb 27 17:47:08 CST 2018}
    [Role{roleId=1, roleName='院长', roleDesc='管理整个学院'}, Role{roleId=2, roleName='总裁', roleDesc='管理整个公司'}]
    --------每个用户的信息---------
    User{id=42, username='update', sex='男', address='XXXXXXX', birthday=Mon Feb 08 19:37:31 CST 2021}
    []
    --------每个用户的信息---------
    User{id=43, username='小二王', sex='女', address='北京', birthday=Sun Mar 04 11:34:34 CST 2018}
    []
    --------每个用户的信息---------
    User{id=45, username='新一', sex='男', address='北京', birthday=Sun Mar 04 12:04:06 CST 2018}
    [Role{roleId=1, roleName='院长', roleDesc='管理整个学院'}]
    --------每个用户的信息---------
    User{id=50, username='Keafmd', sex='男', address='XXXXXXX', birthday=Mon Feb 08 15:44:01 CST 2021}
    []
    --------每个用户的信息---------
    User{id=51, username='update DAO', sex='男', address='XXXXXXX', birthday=Tue Feb 09 11:31:38 CST 2021}
    []
    --------每个用户的信息---------
    User{id=52, username='Keafmd DAO', sex='男', address='XXXXXXX', birthday=Tue Feb 09 11:29:41 CST 2021}
    []
    --------每个用户的信息---------
    User{id=53, username='Keafmd laset insertid 1', sex='男', address='XXXXXXX', birthday=Fri Feb 12 20:53:46 CST 2021}
    []
    --------每个用户的信息---------
    User{id=54, username='Keafmd laset insertid 2 auto', sex='男', address='XXXXXXX', birthday=Fri Feb 12 21:02:12 CST 2021}
    []
    2021-02-13 00:17:33,345 796    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3d36e4cd]
    2021-02-13 00:17:33,346 797    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@3d36e4cd]
    2021-02-13 00:17:33,346 797    [           main] DEBUG source.pooled.PooledDataSource  - Returned connection 1027007693 to pool.
    
    Process finished with exit code 0
    

    以上就是Mybatis的多表关联查询(多对多)的全部内容。

    看完如果对你有帮助,感谢点赞支持!
    如果你是电脑端的话,看到右下角的 “一键三连” 了吗,没错点它[哈哈]

    在这里插入图片描述

    加油!

    共同努力!

    Keafmd

    展开全文
  • MongoDB的多表关联查询

    万次阅读 2017-11-10 18:31:59
    Mongoose的多表关联查询 首先,我们回忆一下,MySQL多表关联查询的语句: student表: calss表: 通过student的classId关联进行查询学生名称,班级的数据: SELECT student.name,student.age,class.name ...
    Mongoose的多表关联查询
    首先,我们回忆一下,MySQL多表关联查询的语句:
    student表:
    calss表:
    通过student的classId关联进行查询学生名称,班级的数据:
    SELECT student.name,student.age,class.name FROM student,class WHERE student.classId = class.id

    Mongoose多表联合查询(还是以众所周知的学生、班级作为实例)
    · 表结构的定义(schemas目录下)
    1. student表(student.js)
    var mongoose = require('mongoose');
    var Schema = mongoose.Schema;
    /*定义数据模式*/
    var StudentSchema = new mongoose.Schema({
        name: String,
        calssId: {
            type: Schema.Types.objectId,
            ref: 'class'
        },
        age: Number,
        number: Number,
        meta: {
            createAt: {
                type: Date,
                default: Date.now()
            },
            updateAt: {
                type: Date,
                default: Date.now()
            }
        }
        /*更新时间的*/
    });
    module.exports = StudentSchema;
    2. class表(class.js)
    var mongoose = require('mongoose');
    var Schema = mongoose.Schema;
    /*定义数据模式*/
    var ClassSchema = new mongoose.Schema({
        name: String,
        meta: {
            createAt: {
                type: Date,
                default: Date.now()
            },
            updateAt: {
                type: Date,
                default: Date.now()
            }
        }
        /*更新时间的*/
    });
    module.exports = ClassSchema;

    · 生成Model(model目录下)
    1. student Model(student.js)
    var mongoose = require('mongoose');
    var StudentSchema = require('../schemas/student');
    
    /*通过model编译模式为模型*/
    var Student = mongoose.model('student', StudentSchema);
    
    /*导出Student模型 模块*/
    module.exports = Student;
    2. class Model(class.js)
    var mongoose = require('mongoose');
    var ClassSchema = require('../schemas/class');
    
    /*通过model编译模式为模型*/
    var Class = mongoose.model('class', ClassSchema);
    
    /*导出Class模型 模块*/
    module.exports = Class;

    · Model进行数据的查询操作
    1. 将静态类的方法加到Model的编译中
    StudentSchema.static = {
        fetch: function(cb){
    	return this
    	     .find({})
    	     .sort('meta.updateAt') //按更新的时间排序
        }
    }
    2. 将静态类方法加到Model中
    StudentSchema.static('fetch', function(cb){
         return this
              .find({}, cb)
    	  .sort('meta.updateAt')
    })
    3. 直接调用model的find()方法
    查询的结果均为:
    [
        {
            _id: '5a05222f583e5720b8660191',
            name: '张三',
            age: 18,
            number: 11,
            classId: '5a0036512b740f32e4371e66'
        },
        {
            _id: '5a05222f583e5720b8660091',
            name: '李四',
            age: 19,
            number: 11,
            classId: '5a0036512b740f32e1371e66'
        },
        {
            _id: '5a05222f583e5720b18660191',
            name: '赵五',
            age: 17,
            number: 11,
            classId: '5a0036512b7420f32e4371e66'
        }
    ]
    · 多表联合查询(学生对应班级)
    StudentSchema.static = {
        findStudentWithClass: function (cb) {
            return this
                .find({})
                .populate('classId')//注意这是联合查询的关键
                .sort('meta.updateAt')
                .exec(cb)
        }
    }
    查询结果:
    [
        {
            _id: '5a05222f583e5720b8660191',
            name: '张三',
            age: 18,
            number: 11,
            classId: {
                _id: '5a0036512b740f32e4371e66',
                name: '一年1班'
            }
        },
        {
            _id: '5a05222f583e5720b8660091',
            name: '李四',
            age: 18,
            number: 11,
            classId: {
                _id: '5a0036512b740f32e1371e66',
                name: '二年2班'
            }
        },
        {
            _id: '5a05222f583e5720b18660191',
            name: '赵五',
            age: 18,
            number: 11,
            classId: {
                _id: '5a0036512b7420f32e4371e66',
                name: '一年2班'
            }
        }
    ]

    · 由上面的实例可知,mongoose的多表联合查询的关键:
    1. 数据模式结构定义需要利用关键字ref定义关联
    var Schema = new mongoose.Schema({
        field: {
    	type: mongoose.Schema.Type.ObjectId,
    	ref: 'model'
        }
    });
    Schema.static = {
        fetch: function(cb){
    	return this
    	      .find({})
    	      .populate('field')
    	      .exec(cb)
    	}
     }
    var Model = mongoose.Model('model',Schema );



    展开全文
  • Mybatis多表关联查询

    千次阅读 2017-08-17 01:17:42
    MyBatis多表关联查询的使用,一对多查询,多对一查询,自关联查询,多对多查询
  • mysql查询语句 和 多表关联查询 以及 子查询

    万次阅读 多人点赞 2017-03-28 14:12:15
    mysql(三):mysql查询语句 和 多表关联查询 以及 子查询 1.查询一张表:  select * from 表名; 2.查询指定字段:select 字段1,字段2,字段3….from 表名; 3.where条件查询:select 字段1,字段2,字段3 ...
  • 近在做项目中遇到多表关联查询排序的效率问题(5张以上40W+数据的表),查询一次大概要20多秒,经过一番苦思冥想,处理方案如下:  1、软件设计初期,需要一对一关联的表应该设计在一张大表里,这样虽然字段多些,...
  • 分享给大家供大家参考,具体如下:Mongoose的多表关联查询首先,我们回忆一下,MySQL多表关联查询的语句:student表:calss表:通过student的classId关联进行查询学生名称,班级的数据:SELECT student.name,student...
  • Oracle多表关联查询

    千次阅读 2017-03-12 17:06:38
    在实际的应用系统开发中会涉及多个数据表,每个表的信息不是独立存在的,而是若干个表之间的信息存在一定的关联,这样当用户查询某一个表的信息时,很可能需要查询关联表的信息,这就是多表关联查询。 1、内连接 内...
  • PyMySQL高级多表关联查询

    千次阅读 2019-10-24 09:54:22
    第一章 模型类添加关联表 第二章 多表关联查询 第三章 查询集QuerySet 第四章 综合案例
  • Spring Data Mongodb多表关联查询

    万次阅读 2018-12-27 16:19:29
    Spring Data Mongodb使用$lookup实现多表关联查询Spring Data Mongodb多表关联查询前言一、实例1、数据准备2、 一对一:两表关联查询3、一对一:多表关联查询4、一对多:关联查询二、讲道理1、自定义...
  • 1.多表(关联)查询多表查询也称之为关联查询、多表关联查询等,主要是指通过多个表的关联来获取数据的一种方式。1.1.多表映射关系一对多:A表的一行数据,对应B表中的多条。如:一个部门可以对应多个员工.多对一:B表...
  • mybatis多表关联查询

    千次阅读 2019-10-19 09:02:12
    多表关联查询 在表关系中,大致分为三类 1.一对一 每个人与自己的身份证之间属于一对一关系,这个很好理解 2.一对多 一个人可以有很多张银行卡,你的多张银行卡对应你自己,这种关系可以理解为一对多,多对一 3.多对多 ...
  • 这里将告诉您结合mybatis-plus 实现实体操作多表关联查询,教程操作方法:multipleselectjava mybatis 实现简单多表查询简介实现简单的实体类操作多表, 首先你的项目是使用了mybatis-plus 才可以使用。​ 通过解析实体...
  • JPA多表关联查询

    千次阅读 2018-05-15 22:11:51
    JPA多表关联查询 作用:就是实现使用一个实体类对象操作或者查询多个表的数据。 回顾:配置多表联系查询必须有两个步骤; 1. 在实体类里面建立表与表之间的关系。 2. 配置关联关系,JPA使用注解配置 一对多配置...
  • 多表关联查询数量

    2020-12-17 17:08:46
    //多表关联查询数量 select user, t1.count1, t2.count2 from user t left join ( select user_id, count(sport_type) as count1 from sport group by user_id ) t1 on t.id = t1.user_id left join ( select user_...
  • oracle多表关联查询和子查询 一、多表关联查询 例子: SQL> create table student1 ( sid varchar(3), sname varchar(6), sage number(3)); Table created. SQL> create table course1 ( sid...
  • 主要介绍了thinkphp中的多表关联查询的实例详解的相关资料,希望通过本文能帮助到大家,让大家理解掌握这部分内容,需要的朋友可以参考下
  • Spring boot 多表关联查询

    千次阅读 2017-04-24 13:05:33
    Spring boot 多表关联查询
  • fastadmin 多表关联查询

    2020-08-28 16:28:25
    fastadmin 多表关联查询 一键生成CRUD,生成的控制器的方法,继承基类,把基类的 index 方法复制到对应的控制器 在index方法加入 $this->relationSearch = true; 为开启关联查询,并关联对应的方法 在model...
  • 最近小学生在使用mybatis多表关联查询时遇到问题,最终凭借高超的搜索技术加以解决,再次总结 mybatis多表关联查询重点是 在resultMap中的association中传入resultMap类型,如 <association property=...
  • 数据库多表关联查询

    2017-06-30 19:49:30
    多表关联查询,两个表之间连接关系可分为左外连接left [outer] join,右连接right [outer] join,全外连接full [outer] join,内连接[inner] join。举例说明下 table student SID NAM

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,102
精华内容 4,840
关键字:

多表关联查询