精华内容
下载资源
问答
  • 嵌套查询和嵌套结果
    千次阅读
    2021-09-26 19:27:08
    嵌套查询嵌套结果
    嵌套查询是在查询 SQL 后再进行一个(子)查询嵌套结果是一个多表查询的 SQL 语句
    会执行多条 SQL 语句只有一条复杂的 SQL 语句(多表连接)
    SQL语句编写较为简单SQL语句编写较为复杂

    更多相关内容
  • 关联的嵌套查询显示得到一个结果集,然后根据这个结果集的每一条记录进行关联查询。 现在假设嵌套查询就一个(即resultMap 内部就一个association标签),现查询结果集返回条数为N,那么关联查询语句将会被执行N次...

    嵌套查询的弊端:即嵌套查询的N+1问题
    尽管嵌套查询大量的简化了存在关联关系的查询,但它的弊端也比较明显:即所谓的N+1问题。关联的嵌套查询显示得到一个结果集,然后根据这个结果集的每一条记录进行关联查询。
    现在假设嵌套查询就一个(即resultMap
    内部就一个association标签),现查询的结果集返回条数为N,那么关联查询语句将会被执行N次,加上自身返回结果集查询1次,共需要访问数据库N+1次。如果N比较大的话,这样的数据库访问消耗是非常大的!所以使用这种嵌套语句查询的使用者一定要考虑慎重考虑,确保N值不会很大。
    嵌套结果查询:
    嵌套语句的查询会导致数据库访问次数不定,进而有可能影响到性能。Mybatis还支持一种嵌套结果的查询:即对于一对多,多对多,多对一的情况的查询,Mybatis通过联合查询,将结果从数据库内一次性查出来,然后根据其一对多,多对一,多对多的关系和ResultMap中的配置,进行结果的转换,构建需要的对象。

    展开全文
  • 嵌套查询是多条sql语句分开写并配置,嵌套结果是一条sql语句关联查询并配置,实质效果是一样的。嵌套语句的查询会导致数据库访问次数不定,进而有可能影响到性能。 1.创建2张表,建立主外键关系 2.建立实体类 ...

    嵌套查询是多条sql语句分开写并配置,嵌套结果是一条sql语句关联查询并配置,实质效果是一样的。嵌套语句的查询会导致数据库访问次数不定,进而有可能影响到性能。

    1.创建2张表,建立主外键关系
    在这里插入图片描述

    2.建立实体类

    package com.yw.test06;  
      
      
    public class Class  
    {  
        private int id;  
        private String name;  
          
          
        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;  
        }  
        @Override  
        public String toString()  
        {  
            return "Class [id=" + id + ", name=" + name + "]";  
        }  
          
          
    }  
    [html]  view plain  copy
    
    package com.yw.test06;  
      
    public class Student  
    {  
        private int id;  
        private String name;  
        private int age;  
        private Class c;  
          
        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 int getAge()  
        {  
            return age;  
        }  
        public void setAge(int age)  
        {  
            this.age = age;  
        }  
        public Class getC()  
        {  
            return c;  
        }  
        public void setC(Class c)  
        {  
            this.c = c;  
        }  
        @Override  
        public String toString()  
        {  
            return "Student [id=" + id + ", name=" + name + ", age=" + age + ", c=" + c + "]";  
        }  
      
          
          
    }  
    

    3.修改配置文件

    <?xml version="1.0" encoding="UTF-8" ?>  
    <!DOCTYPE configuration  
      PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
      "http://mybatis.org/dtd/mybatis-3-config.dtd">  
    <configuration>  
        <properties resource="config.properties">  
        </properties>  
        <typeAliases>  
            <!-- <typeAlias type="com.yw.test06.StudentMapper" alias="Student" />  
            <typeAlias type="com.yw.test06.ClassMapper" alias="Class" /> -->  
            <package name="com.yw.test06"/>  
        </typeAliases>  
        <environments default="development">  
            <environment id="development">  
                <transactionManager type="JDBC" />  
                <dataSource type="POOLED">  
                    <property name="driver" value="${driver}" />  
                    <property name="url" value="${url}" />  
                    <property name="username" value="${username}" />  
                    <property name="password" value="${password}" />  
                </dataSource>  
            </environment>  
        </environments>  
        <mappers>  
            <!-- <mapper resource="org/mybatis/example/BlogMapper.xml"/> -->  
            <mapper resource="com/yw/test06/StudentMapper.xml" />  
        </mappers>  
      
    </configuration>  
    

    4.建立映射文件
    1)嵌套查询

    <?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.yw.test07.StudentMapper">  
      
        <select id="selectStudent" resultMap="studentResult">  
            SELECT * FROM student s  
            WHERE s.ID = #{id}  
        </select>  
        <resultMap type="Student" id="studentResult">  
            <association property="c" column="c_id" javaType="Class"  
                select="selectClass" />  
        </resultMap>  
      
        <select id="selectClass" resultType="Class">  
            SELECT * FROM class WHERE ID= #{id}  
        </select>  
      
    </mapper>  
    

    2)嵌套结果

    <?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.yw.test06.StudentMapper">  
      
          
        <resultMap id="studentResult" type="com.yw.test06.Student">  
            <id property="id" column="id"/>  
            <result property="name"  column="name"/>  
            <result property="age"  column="age"/>  
      
            <association property="c" resultMap="classResult"  
                javaType="Class"></association>  
      
        </resultMap>  
        <resultMap type="com.yw.test06.Class" id="classResult">  
            <id property="id" column="id"/>  
            <result property="name" column="name"/>  
        </resultMap>  
       
        <select id="selectStudent" resultMap="studentResult">   
            SELECT s.id,c.id,s.name,s.age,c.name from student s  left join class c on c.id=s.c_id where s.id=#{id}  
        </select>  
      
      
      
    </mapper>  
    

    5.创建测试类

    package com.yw.test06;  
      
    import java.io.IOException;  
    import java.io.InputStream;  
      
    import org.apache.ibatis.io.Resources;  
    import org.apache.ibatis.session.SqlSession;  
    import org.apache.ibatis.session.SqlSessionFactory;  
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
      
    public class Test01  
    {  
        public static void main(String[] args) throws IOException  
        {  
              
            String resource = "com/yw/test06/mybatis-config.xml";  
            InputStream inputStream = Resources.getResourceAsStream(resource);  
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
              
            SqlSession session = sqlSessionFactory.openSession(false);  
            try {  
              Student user = (Student) session.selectOne("com.yw.test06.StudentMapper.selectStudent", 1);  
              System.out.println(user);           
                  
            } finally {  
              session.close();  
            }  
        }  
    }  
    

    引用链接:https://blog.csdn.net/suchahaerkang/article/details/80262626

    展开全文
  • } 可以看到结果如下所示: 嵌套结果 虽然使用嵌套查询的方式比较简单,但是从图9中可以看出,MyBatis嵌套查询的方式要执行多条SQL语句,这对于大型数据集合列表展示不是很好,因为这样可能会导致成百上千条关联...

    关联映射概述
    在实际的开发中,对数据库的操作常常会涉及多张表,这在面向对象中就涉及了对象与对象之间的关联关系 针对多表之间的操作, MyBatis 提供了关联映射,通过关联映射就可以很好地处理对象与对象间的关联关系

    这3中关系怎么关联起来呢?

    • 一对一 :在任意一方引入对方主键作为外键
    • 一对多 :在"多"的一方,添加"一"的一方的主键作为外键
    • 多对多 :产生中间关系表,引入两张表的主键作为外键,两个主键成为联合主键或使用新
      的宇段作为主键

    在Java当中,通多随想也可以进行关系描述:如下图所示
    在这里插入图片描述
    三种关联的描述如下

    • 一对一的关系:就是在本类中定义对方类型的对象,如A类中定义B类类型的属性b, B类中定义A类类型的属性a。
    • 一对多的关系:就是一个A类类型对应多个B类类型的情况,需要在A类中以集合的方式引入B类类型的对象,在B类中定义A类类型的属性a。
    • 多对多的关系:在A类中定义B类类型的集合,在B类中定义A类类型的集合。

    一对一关联映射

    resultMap元素下包含一个association的子元素,在MyBatis当中就是通过这一子元素来处理一对一关联映射的。MyBatis映射文件Mapper.xml详解 单击前往

    在association元素中通常会要配置到以下元素

    • property:指定映射到的实体类对象属性,与表字段一一对应
    • javaType:指定映射到实体对象属性的类型(一个类的类型)
    • column:指定表中对应的字段
    • select:指定引入嵌套查询的子 SQL 语句,该属性用于关联映射中的嵌套查询
    • fetchType:指定在关联查询时是否启用延迟加载 fetchType 属性有 lazy eager 两个属性值,默认值为 lazy (即默认关联映射延迟加载)

    MyBatis 在映射文件中加载关联关系对象主要通过两种方式:嵌套查询和嵌套结果,嵌套查询是指通过执行另外一条 SQL 映射语句来返回预期的复杂类型;嵌套结果是使用嵌套结果映射来处理重复的联合结果的子集。
    以下案例通过一个人只有一个身份证号码的案例来说明这个一对一的关系:
    首先在数据库当中建立一个身份信息表,和个人信息表:其中把身份表的id列引入到个人表当中作为外键。建表后插入俩条数据用于测试

    CREATE TABLE tb_idcard( 
    id INT PRIMARY KEY AUTO_INCREMENT,
    CODE VARCHAR (18));
    
    INSERT INTO tb_idcard (CODE) VALUES('430481200001011111')
    INSERT INTO tb_idcard (CODE) VALUES('430481200001012222')
    
    CREATE TABLE tb_person(
    id INT PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(32),
    age INT,
    sex VARCHAR(8),
    card_id INT UNIQUE,
    FOREIGN KEY (card_id) REFERENCES tb_idcard(id)
    )
    
    INSERT INTO tb_person(NAME,age,sex,card_id)VALUES('汤姆',20,'男',1);
    INSERT INTO tb_person(NAME,age,sex,card_id)VALUES('李红',20,'女',2);
    
    SELECT * FROM tb_person
    SELECT * FROM tb_idcard
    

    所有该项目文件的层次如下图:所需要的的包也就是MyBatis的包和数据库驱动包:第一个MyBatis程序,单击前往:
    在这里插入图片描述
    随后建立其对应的java类:对每一列的列名进行getset封装以及重写toString方法:
    IdCard类

    package com.lzq.po;
    public class IdCard {
    	private Integer id;
    	private String code;
    //getset方法省略
    	@Override
    	public String toString() {
    		return "IdCard [id =" + id + ",code=" + code + "]";
    	}
    }
    

    Person类

    package com.lzq.po;
    public class Person {
    	private Integer id;
    	private String name;
    	private Integer age;
    	private String sex;
    	private IdCard card;
    	@Override
    	public String toString() {
    		return "Person [id =" + id + ",name=" + name + ",age=" + age + ",sex= " + sex + ",card=" + card + "]";
    	}
    }
    

    嵌套查询

    随后在mapper包下进行配置mapper文件:
    使用了MyBatis 中的嵌套查询方式进行了个人及其关联的证件信息查询,因为返回的个人对象中除了基本属性外还有一个关联的card属性,所以需要手动编写结果映射。从映射文件PersonMapper.xml中可以看出,嵌套查询的方法是先执行一-个简单的SQL语句,然后在进行结果映射时,将关联对象在<association>元素中使用select属性执行另一条SQL语句(即ldCardMapper.xml中的SQL )。

    IdCardMapper.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.lzq.mapper.IdCardMapper">
      <select id="findCodeById" parameterType="Integer" resultType="IdCard">
    	  SELECT * from tb_idcard where id=#{id}
      </select>
    </mapper>
    

    PersonMapper.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.lzq.mapper.PersonMapper">
    	<select id="findPersonById" parameterType="Integer"
    		resultMap="IdCardWithPersonResult">
    		select * from tb_person where id =#{id}
    	</select>
    	<resultMap type="Person" id="IdCardWithPersonResult">
    		<id property="id" column="id" />
    		<result property="name" column="name" />
    		<result property="age" column="age" />
    		<result property="sex" column="sex" />
    		<association property="card" column="card_id"
    			javaType="IdCard" select="com.lzq.mapper.IdCardMapper.findCodeById" />
    	</resultMap>
    </mapper>
    

    以及在mybatis-config.xml文件当中进行配置mapper文件:

    <mapper resource="com/lzq/mapper/PersonMapper.xml" />
    <mapper resource="com/lzq/mapper/IdCardMapper.xml" />
    

    最后在测试类当中编写方法进行测试:
    在这里面是将获取session对象的代码进行封装了:参考:核心对象
    在这一篇文章最后的就是封装的代码,在编写是导入这个类即可调用MybatisUtils.getSession()

    public void findPersonByIdCardTest() {
    		SqlSession session = MybatisUtils.getSession();
    		Person person = session.selectOne("com.lzq.mapper"+".PersonMapper.findPersonById",1);
    		System.out.println(person);
    		session.close();
    	}
    

    可以看到结果如下所示:
    在这里插入图片描述
    嵌套结果

    虽然使用嵌套查询的方式比较简单,但是从图9中可以看出,MyBatis嵌套查询的方式要执行多条SQL语句,这对于大型数据集合和列表展示不是很好,因为这样可能会导致成百上千条关联的SQL语句被执行,从而极大地消耗数据库性能并且会降低查询效率。为此,我们可以使用MyBatis提供的嵌套结果方式来进行关联查询。
    在PersonMapper.xml文件当中添加以下查询方式:使用多表联接查询
    MyBatis 嵌套结果的方式只编写了一条复杂的多表关联的 SOL 语句,并且在<association> 元素中继续使用相关子元素进行数据库表字段和实体类属性的一一映射

    <select id="findPersonById2" parameterType="Integer"
    		resultMap="IdCardWithPersonResult2">
    		select p.* ,idcard.code from tb_person p,tb_idcard idcard
    		where p.card_id =idcard.id and p.id= #{id}
    	</select>
    	<resultMap type="Person" id="IdCardWithPersonResult2">
    		<id property="id" column="id" />
    		<result property="name" column="name" />
    		<result property="age" column="age" />
    		<result property="sex" column="sex" />
    		<association property="card" javaType="IdCard">
    			<id property="id" column="card_id" />
    			<result property="code" column="code" />
    		</association>
    	</resultMap>
    

    使用同样的测试方法测试:如下图所示:在使用嵌套结果的方式进行查询的时候只会执行一条SQL语句,
    在这里插入图片描述
    延迟加载
    在使用 MyBatis 换套查询方式进行 MyBatis 关联查询映射时,使用 MyBatis 的延迟加载在一定程度上可以降低运行消耗并提高查询效率 MyBatis 默认没有开启延迅加载,需要在核心配直文件 mybatis-config.xml 中的<settings>元素内进行配直,具体配直方式如下:

    <settings> 
    <!--打开延迟加载的开关-->
    <setting name="lazyLoadingEnabled" value="true" /> 
    <!--将积极加载改为消息加载,即按需加载-->
    <setting ame="aggressiveLazyLoading" value="false"/> 
    </settings>
    

    在映射文件中, MyBatis 关联映射的 <association>元索和<collection>元素中都已默认配置了延迟加载属性 即默认属性 fetchType=“lazy” (属性 fetchType="eager"表示立即力口载),

    下一篇 :MyBatis的关联映射之 一对多 和 多对多

    展开全文
  • mybatis 高级关联集合映射:嵌套查询和嵌套结果小案例,帮助更好的理解关联集合的使用
  • Mybatis 在映射文件中加载关联关系对象主要通过两种方式:嵌套查询嵌套结果嵌套查询是指通过执行另外一条 SQL 映射语句来返回预期的复杂类型; 嵌套结果是使用嵌套结果映射来处理重复的联合结果的子集。 ....
  • MyBatis在映射文件中加载关联关系对象主要通过两种方式:嵌套查询和嵌套结果嵌套查询是指通过执行另外一条SQL映射语句来返回预期的复杂类型; 嵌套结果是使用嵌套结果映射来处理重复的联合结果的子集。开发人员可以...
  • 数据库嵌套查询总结

    2017-12-14 13:12:32
    数据库嵌套查询总结 还有其他数据库使用总结,稍后上传
  • 关联的嵌套查询显示得到一个结果集,然后根据这个结果集的每一条记录进行关联查询。 现在假设嵌套查询就一个(即resultMap 内部就一个association标签),现查询结果集返回条数为N,那么关联查询语句将会被执行N次...
  • MySQL嵌套查询(子查询

    千次阅读 2021-01-18 18:14:16
    子查询一般不使用order by子句,只能对最终查询结果进行排序。另一种定义:在一个SELECT 语句的WHERE 子句或HAVING 子句中嵌套另一个SELECT 语句的查询称为嵌套查询,又称子查询。嵌套查询的工作方式...
  • mybatis嵌套结果和嵌套查询

    千次阅读 2020-04-25 22:41:11
    嵌套结果 是一次查询 然后映射到对应属性 嵌套查询是多次查询 有N+1问题 解决方法就是使用懒加载和嵌套结果 我们经常用的查询也就是嵌套结果查询 https://www.cnblogs.com/fly-book/p/10405222.html ...
  • Mysql中嵌套查询和连接查询的区别

    千次阅读 2022-04-28 20:16:42
    一、嵌套查询 嵌套查询我们以mybatis中的嵌套查询举例: 1.1、创建数据库 CREATE TABLE `teacher` ( `id` INT(10) NOT NULL, `name` VARCHAR(30) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=INNODB DEFAULT ...
  • resultMap嵌套结果和嵌套查询

    千次阅读 2020-05-16 19:00:29
    最近我们在学习result嵌套结果和嵌套查询。今天就来总结一下。 准备工作 首先呢,我们要 做好准备工作。 1.在数据库中创建两个表。 2.准备好我们需要的jar包 3.准备好我们要的配置文件 4.创建好两个表的pojo包 创建...
  • SQL子查询和嵌套查询

    2012-05-14 20:51:48
    SQL子查询和嵌套查询
  • 嵌套查询和嵌套结果嵌套查询: 是指通过执行另外一条SQL映射语句来返回预期的复杂类型。 会执行多条sql语句 嵌套结果查询: 是使用嵌套结果映射来处理重复的联合结果的子集。 只会执行一条复杂的sql语句 简单来说...
  • 1.集合的嵌套查询
  • mybatis的关联嵌套查询--分页详解

    千次阅读 2018-11-25 19:46:21
    1. mybatis嵌套查询后,分页混乱:mybatis通过查询结果之后折叠结果集把数据放在了集合里,这就导致总条数的混乱.而第一种的方式是分两次查询,就不会有分页的问题,所以解决方案就是把你的collection写成第一种的方式 ...
  • SQL Server 数据库之嵌套查询

    千次阅读 2022-03-16 13:59:32
    SQL Server 数据 嵌套查询
  • 实验3 连接查询和嵌套查询

    千次阅读 2021-05-13 19:12:57
    2.熟练掌握简单表的数据连接查询和嵌套查询的操作方法。 实验内容: 创建教学管理数据库“JXGL”,在“JXGL”数据库中创建3-2中的三张表并添加数据,实现数据的单表查询操作。 实验步骤: 写出下列操作的SQL语句 在...
  • ES的嵌套查询和嵌套聚合

    千次阅读 2019-04-29 11:17:59
    1.想要实现嵌套查询和嵌套聚合,首先需要在索引里面设置某个属性是嵌套类型(一般是List)-----type=nested 2.API的demo-嵌套查询---(使用场景:需要根据list中的两个字段以and的关系进行查询) // 构造布尔查询...
  • 11.MyBatis的嵌套查询

    千次阅读 2022-02-23 23:02:39
    嵌套查询就是将原来多表查询中的联合查询语句拆成单个表的查询,再使用mybatis的语法嵌套在一 起。 例子: * 需求:查询一个订单,与此同时查询出该订单所属的用户 1. 联合查询 SELECT * FROM orders o LEFT JOIN ...
  • MYSQL嵌套查询(子查询),把内层的查询结果作为外层的查询条件牛逼PHP2019年10月07日364 views嵌套查询(子查询)1、定义 :把内层的查询结果作为外层的查询条件2、语法格式select ... from 表名 where 条件(select .......
  • SQL连接查询和嵌套查询详解

    千次阅读 2020-08-19 14:30:02
    SQL连接查询和嵌套查询详解 连接查询 若一个查询同时涉及两个或两个以上的表,则称之为连接查询。连接查询是数据库中最最要的查询, 包括1、等值与非等值连接查询2、自然连接查询 1、等值连接查询 2、自然连接查询 3...
  • Oracle数据库SQL语句(四) 一、子查询嵌套查询) 1、单行子查询 SELECT * FROM stu WHERE ID > (SELECT ID FROM stu WHERE NAME ='王五'); 2、多行子查询 ... --= ANY :查询中任意一个结果相等
  • SQL 嵌套查询

    千次阅读 2021-01-14 09:39:12
    嵌套查询的工作方式是由内向外的,即先进行内层查询,外层查询则利用内层查询结果集作为条件进行查询。当然,嵌套查询不仅仅是select语句的专属,它还可以用在update、insert、delete语句中。如(update...
  • MySQL的嵌套查询

    千次阅读 2021-01-18 18:14:10
    最近在MySQL上做了点工作,发现很多人都在询问MySQL嵌套查询的问题,许多人都觉得MySQL不支持嵌套查询,其实MySQl从4.11版后已经完全支持嵌套查询了,那么下面我举些简单的嵌套查询的例子吧(源程序来自MySQL User ...
  • mybatis -- 嵌套查询

    千次阅读 2022-05-23 22:36:09
    嵌套查询
  • sql嵌套查询

    千次阅读 2021-10-08 14:27:40
    bookshop查询 1、在sales表中查找出销售金额最高的订单(订单号,销售金额,订购日期) SELECT order_no AS 订单号, total_amt AS 销售金额, order_date AS 订购日期 FROM sales WHERE total_amt = ( SELECT ...
  • Oracle数据库的嵌套查询

    千次阅读 2019-03-28 11:17:44
    在前面2个章节,我们比较详细的介绍了一些SQL语句的基本用法,但是在我们实际的项目开发中,其实很多时候这些基本的用法远远不能满足我们项目的需求,这个时候就需要我们的嵌套查询。 在SQL语句中,一个select-from-...
  • 数据库【嵌套查询

    千次阅读 2021-04-06 12:44:44
    select Sname from Student where Sno in( select Sno ...[例 3.58] 查询非计算机科学系中比计算机科学系任意一个学生年龄小的学生姓名年龄。 [例 3.59] 查询非计算机科学系中比计算机科学...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,119,412
精华内容 447,764
关键字:

嵌套查询和嵌套结果