精华内容
下载资源
问答
  • 动态sql
    千次阅读
    2021-10-27 16:21:38

    一、什么是动态SQL

    一般的PL/SQL程序设计中,在DML和事务控制的语句中可以直接使用SQL,但是DDL语句及系统控制语句却不能在PL/SQL中直接使用,要想实现在PL/SQL中使用DDL语句及系统控制语句,可以通过使用动态SQL来实现。
    在Oracle数据库开发PL/SQL块中我们使用SQL分为静态SQL动态SQL
    静态SQL指在PL/SQL块中使用的SQL语句在编译时是明确的,执行的是确定对象。
    例:

    select * from emp where emp=7788;
    

    动态SQL是指在PL/SQL块编译时SQL语句是不确定的,比如根据用户输入参数的不同而执行不同的操作。
    例:

    select * from emp where empno='&员工编号';
    

    动态SQL就是将SQL语句写在一个字符串中,在存储过程中解析字符串执行SQL。

    二、动态SQL的作用

    1. 支持DDL语句,而静态SQL只能支持DML语句;
    2. 支持web引用程序的查询意愿( 一个网络应用程序的常见需求是用户可以指定他们想看到的列, 以及改变数据的排序方式 );
    3. 可以将业务逻辑先放在表中,然后再动态编译

    三、动态SQL语句的五种实现方法

    1. 使用 execute immediate 语句
      可以执行DDL语句、DCL语句、DML语句以及单行select语句。但这个方法不能用于处理多行查询语句。
    2. &参数输入
    3. 使用游标(open-for, fetch,close语句)
      是对于处理动态多行的查询操作,使用open-for语句打开游标,fetch语句循环获取数据,最后使用close语句关闭游标。
    4. 使用批量动态SQL
      即在动态SQL中使用BULK子句,或使用游标变量时在fetch中使用BULK ,或在FORALL语句中使用BULK子句来实现。
    5. 使用系统提供的PL/SQL包 DBMS_SQL 实现
      此处重点讲述第一种,其它三种带过

    四、动态SQL的语法结构

    execute immediate 动态语句字符串
    [into 变量列表]
    [using 参数列表]

    解释:
    动态语句字符串:存储指定的SQL语句或者PL/SQL块的字符串变量
    into:用于存储查询结果
    using:参数传递值
    动态SQL传参数的格式:[:参数名],参数在运行时需要使用using传值

    五、动态SQL的写法

    写法1:不传参不赋值

    --拷贝emp表
    begin
      execute immediate 'create table test1 as select * from emp';	
      --字符串语句最后不需要加分号
    end;
    --创建表
    begin
      execute immediate 'create table temp_table2 ' || '( id integer ,name varchar2(20))';
    end;
    

    写法2:将结果集存在变量中动态运行

    --拷贝emp表
    declare
      sqls varchar2(100) := 'create table test1_emp as select * from emp';
    begin
      execute immediate sqls;
    end;
    

    写法3:动态SQL传参和赋值

    using 传参
    into 赋值
    参数格式 [:参数]

    --案例:根据员工编号查询员工薪资
    declare
      v_sal emp.sal%type;
    begin
      --执行动态SQL
      execute immediate 'select sal from emp where empno=:员工编号'
      --变量赋值
      into v_sal
      --接收参数
      using &请输入员工编号;
      dbms_output.put_line('工资:' || v_sal);
    end;
    

    写法4:动态SQL只赋值不传参

    --案例:根据员工编号查询员工薪资
    declare
      v_sal emp.sal%type;
    begin
      --执行动态SQL
      execute immediate 'select sal from emp where empno=7788'
      --变量赋值
      into v_sal;
      dbms_output.put_line('工资:' || v_sal);
    end;
    
    

    六、动态SQL与存储过程的运用

    案例1:删除表(通过传递表名对相应的表进行删除)

    -- 创建一个存储过程,通过传递表名对相应的表进行删除
    create or replace procedure truncate_table(table_name in varchar2)
    is
    sqls varchar2(100);
    begin
      sqls := 'truncate table ' || table_name; --为变量赋值,用于生成动态的SQL语句
      execute immediate sqls;
    end;
    -- 调用存储过程删除test111表
    begin
      truncate_table('test111');
    end;
    

    案例2:创建表(根据用户输入的表名及字段名等参数创建表)

    --创建表:根据用户输入的表名及字段名等参数创建表
    create or replace procedure create_table(
    table_name in varchar2,----表名
    field1 in varchar2,---字段1
    field1type in varchar2,---字段1的数据类型
    field2 in varchar2,---字段2
    field2type in varchar2,---字段2的数据类型
    field3 in varchar2,---字段3
    field3type in varchar2---字段3的数据类型 最后一个参数后面不加逗号
    )
    is 
    sqls varchar2(500);
    begin
      sqls := 'create table' || ' ' || table_name || '(' || field1 || ' ' || field1type || ',' || field2 || ' ' || field2type ||',' || field3 ||' ' || field3type || ')';
      -- 即:create table table_name (field1 field1type,field2 field2type,field3 fieldtype)
      execute immediate sqls;
    end;
    --调用存储过程创建表
    begin
    create_table('test_table','id','varchar2(100)','sno','varchar2(100)','sname','varchar2(100)');
    end;
    

    案例3:插入数据(根据用户输入的字段数据向指定表插入数据)

    --插入数据
    create or replace procedure insert_table(
    id in varchar2,
    name in varchar2,
    age in varchar2
    )
    is
    sqls varchar2(500);
    begin
      sqls:='insert into test_table values(:1,:2,:3)';
      execute immediate sqls using id,name,age;
    end;
    --调用存储过程insert_table插入数据
    begin
      insert_table('1','小红','18');
    end;
    
    
    更多相关内容
  • 动态sql

    千次阅读 2022-06-04 13:07:28
    动态sql

    1.什么是动态sql

    sql的内容是变化的, 可以根据条件获取到不同的sql语句.
    主要是where部分发生变化。
    动态sql的实现, 使用的是mybatis提供的标签

    2.为什么使用动态sql

    使用动态sql可以解决某些功能的使用 例如使用条件查询某个商品 你输入价格,地区等等进行筛选,如果使用静态sql可能会查询出来的是一个空内容 但使用动态sql可以很好的解决这种问题 例如
    在这里插入图片描述

    3.动态sql的标签

    在这里插入图片描述

    3.1 if标签-单条件判断

    作用:筛选条件语句
    dao层方法为:

    public User findConditon(@Param("name")String name, @Param("email")String email);
    

    mapper层

     <!--如果姓名不为空则安姓名查找 如果姓名为空则按邮箱查找 否则查询全部-->
        <select id="findConditon" resultType="com.wx.entity.User">
            select * from tbl_user02
            <where>
                <if test="name!=null and name!=''">
                    and name = #{name}
                </if>
                <if test="email!=null and email!=''">
                    and email = #{email}
                </if>
            </where>
        </select>
    

    3.2 choose标签 多条件分支判断

    //当三者不为空的时候 按姓名 密码 邮件查询 三个条件都会执行一遍
    public User findByCondition(@Param("name")String name, @Param("email")String email,
                                    @Param("pwd")String pwd);
                                    
    
    <select id="findByCondition" resultType="com.wx.entity.User">
            select * from tbl_user02
            <where>
                <choose>
                    <when test="name!=null and name!=''">
                        and name = #{name}
                    </when>
                    <when test="email!=null and email!=''">
                        and email = #{email}
                    </when>
                    <otherwise>
                        and pwd = #{pwd}
                    </otherwise>
                </choose>
            </where>
        </select>
    

    3.3 where语句

    如果不使用where语句 就要在where其他判断语句前加入1=1 如 select * from tbl_user02 where 1=1加其他的if判断语句 如果我们不加入这个1=1就可以直接使用where语句 上面的choose和if都搭配使用 使用where 语句 可以自动消除第一个条件中的and 且加上where 例子如上面两个标签中即可

    3.4set标签

    这个标签配合if标签一起用 一般用于修改语句 如果传递的参数为null 那么就不会修改该列的值

     public int updateUser(User user);
    
    
    //这里注意 test="参数" 这里的参数 是前端传过来的值就是你前端页面上是什么 这里就要写什么 
    //而下面的name=#{name} 第一个name是你数据库中的字段 #{name}中是你的前端传过来的值
    <update id="updateUser" parameterType="User">
            update tbl_user02
            <set>
                <if test="name!=null and name!=''">
                    name=#{name},
                </if>
                <if test="pwd!=null">
                    pwd=#{pwd},
                </if>
                <if test="email!=null">
                    email=#{email},
                </if>
            </set>
            where id = #{id}
        </update>
    

    3.4foreach标签

    循环标签 适用于批量添加、删除 和查询记录

    3.4.1用于批量查询

    查询id为1 3 5 的用户信息
    正常sql语句为 select * from tbl_user02 where id in(1,3,5);
    下面的为使用foreach遍历 循环查询
        解释:
        <foreach collection="集合类型" open="开始的字符" close="结束的字符"
    	    item="集合中的成员" separator="集合成员之间的分割符">
            #{item的值}
        </foreach>
       标签属性:
       collection:表示循环的对象是数组还是list集合。如果dao方法的形参是数组,collection="array";
    		如果dao方法形参是list,collection="list";
       open:循环开始的字符。sql.append("(");
       close:循环结束的字符。sql.append(")");
       item:集合成员,自定义的变量。Integer item = idList.get(i);
       separator:集合成员之间的分隔符。sql.append(",");
       #{item的值}:获取集合成员的值;
    

    具体代码实现
    dao层

    //传递的参数为id数组所以mapper层的collection="list"
    public List<User> findByIds(Integer[] ids);
    

    mapper层为

        <select id="findByIds" resultType="com.wx.entity.User">
            select * from tbl_user02 where id in
            <foreach collection="array" item="id" open="(" close=")" separator=",">
                #{id}
            </foreach>
        </select>
    

    测试类为:

    @Test
        public void testFindByIds() throws Exception{
            Reader rd = Resources.getResourceAsReader("conf.xml");
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(rd);
            SqlSession session = factory.openSession();
            UserDao userDao = session.getMapper(UserDao.class);
            Integer[] ids = {1,3,5};
            List<User> user = userDao.findByIds(ids);
            System.out.println(user);
            session.close();
        }
    

    查询出三条记录
    在这里插入图片描述

    3.4.2用于批量删除

    dao层

    public int BatchDelete(Integer[] ids);
    

    mapper层

      <delete id="BatchDelete">
            delete from tbl_user02 where id in
            <foreach collection="array" item="id" open="(" close=")" separator=",">
                #{id}
            </foreach>
        </delete>
    

    测试类:

    @Test
        public void testBatchDelete() throws Exception{
            Reader rd = Resources.getResourceAsReader("conf.xml");
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(rd);
            SqlSession session = factory.openSession();
            UserDao userDao = session.getMapper(UserDao.class);
            Integer[] ids = {1,3,5};
            int row = userDao.BatchDelete(ids);
            System.out.println(row);
            session.commit();
            session.close();
        }
    

    在这里插入图片描述

    3.4.3用于批量添加

    dao层

    public int batchAdd(List<User> users);
    

    mapper层

       <!--注意 因为循环添加的为一个对象 所以下面添加的值就必须是users.name ...-->
        <insert id="batchAdd">
            insert into tbl_user02(name,pwd,email) values
            <foreach collection="list" item="users" separator=",">
                (#{users.name},#{users.pwd},#{users.email})
            </foreach>
    
        </insert>
    

    测试类:

    @Test
        public void testBatchAdd() throws Exception{
            Reader rd = Resources.getResourceAsReader("conf.xml");
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(rd);
            SqlSession session = factory.openSession();
            UserDao userDao = session.getMapper(UserDao.class);
            List<User> list = new ArrayList<User>();
            list.add(new User("张三","123","zs@qq.com"));
            list.add(new User("李四","123","ls@qq.com"));
            list.add(new User("王五","123","ww@qq.com"));
            int row = userDao.batchAdd(list);
            System.out.println(row);
            session.commit();
            session.close();
        }
    

    在这里插入图片描述

    3.4.4sql片段

    一般用于查询语句的时候 select * … 这种不推荐 所以用sql片段可以很好的解决这个问题
    在这里插入图片描述

    4.mybatis映射文件处理特殊字符.

    当我们使用条件语句查询的时候 就比如在某个范围中使用条件如 money>100 and money<200
    这个条件在mapper中无法直接写所以需要特殊处理,有两种解决办法:

       第一种:转义标签 &nbsp; &lt;  
       第二种: <![CDATA[sql]]>
    
    <select id="findByMaxAndMin" resultType="com.ykq.entity.Account">
           <![CDATA[select * from account where id >#{min} and id <#{max}]]>
    </select>
    

    第一种:转义字符处理
    dao层

     public User findByMaxAndMin(@Param("min") int min,@Param("max") int max);
    

    mapper层

     <select id="findByMaxAndMin" resultType="com.wx.entity.User">
            select * from tbl_user02 where id &gt;#{min} and id &lt; #{max}
        </select>
    

    测试类

        @Test
        public void testFindByMaxMin() throws Exception{
            Reader rd = Resources.getResourceAsReader("conf.xml");
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(rd);
            SqlSession session = factory.openSession();
            UserDao userDao = session.getMapper(UserDao.class);
            User user = userDao.findByMaxAndMin(1, 3);
            System.out.println(user);
            session.commit();
            session.close();
        }
    

    在这里插入图片描述
    第二种: <![CDATA[sql]]>

    dao层

    public User findByMaxAndMin01(@Param("min") int min,@Param("max") int max);
    

    实体层

    <select id="findByMaxAndMin01" resultType="com.wx.entity.User">
             <![CDATA[select * from tbl_user02 where id>#{min} and id<#{max}]]>
        </select>
    

    测试类

     @Test
        public void testFindByMaxMin01() throws Exception{
            Reader rd = Resources.getResourceAsReader("conf.xml");
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(rd);
            SqlSession session = factory.openSession();
            UserDao userDao = session.getMapper(UserDao.class);
            User user = userDao.findByMaxAndMin01(1, 3);
            System.out.println(user);
            session.commit();
            session.close();
        }
    

    在这里插入图片描述

    5.mybatis完成模糊查询

    语法:select * from 表名 where 列名 like ‘%a%’ 但是% a %这样在mapper层无法使用 解决办法有两种
    第一种:使用字符串函数(concat)完成拼接
    dao层

        /*模糊查询*/
        public User findByName(@Param("name")String name);
    

    mapper层

    <select id="findByName" resultType="com.wx.entity.User">
            select * from tbl_user02 where name like concat('%',#{name},'%');
        </select>
    

    测试类

        @Test
        public void testFindByName() throws Exception{
            Reader rd = Resources.getResourceAsReader("conf.xml");
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(rd);
            SqlSession session = factory.openSession();
            UserDao userDao = session.getMapper(UserDao.class);
            User user = userDao.findByName("李");
            System.out.println(user);
            session.close();
        }
    

    在这里插入图片描述
    第二种:使用${}

     <select id="findByName" resultType="com.wx.entity.User">
            select * from tbl_user02 where name like '%${name}%';
        </select>
    

    两者区别:concat不能解决sql注入的问题 第二种是预编译 可以解决sql注入问题

    展开全文
  • 动态SQL

    千次阅读 2021-07-20 20:59:47
    动态SQL 官方中文文档:https://mybatis.org/mybatis-3/zh/dynamic-sql.html 什么是动态SQL动态SQL就是指根据不同的条件生成不同的SQL语句 动态SQL就是在拼接SQL语句,我们只要保证SQL的正确性,按照SQL的格式,去...

    动态SQL

    官方中文文档:https://mybatis.org/mybatis-3/zh/dynamic-sql.html

    什么是动态SQL:动态SQL就是指根据不同的条件生成不同的SQL语句

    动态SQL就是在拼接SQL语句,我们只要保证SQL的正确性,按照SQL的格式,去排列组合就可以了

    • 如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器,你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中,需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式,MyBatis 3 替换了之前的大部分元素,大大精简了元素种类,现在要学习的元素种类比原来的一半还要少。
      
      - if
      - choose (when, otherwise)
      - trim (where, set)
      - foreach
      

    搭建环境

    CREATE TABLE `blog`(
    `id` VARCHAR(50) NOT NULL COMMENT "博客id",
    `title` VARCHAR(100) NOT NULL COMMENT "博客标题",
    `author` VARCHAR(30) NOT NULL COMMENT "博客作者",
    `create_time` DATETIME NOT NULL COMMENT "创建时间",
    `views` INT(30) NOT NULL COMMENT "浏览量"
    )ENGINE=INNODB DEFAULT CHARSET=utf8
    

    创建一个基础工程

    1、导包

    2、编写配置文件

    配置文件中添加setting配置

    <!--        开启驼峰命名转化-->
            <setting name="mapUnderscoreToCamelCase" value="true"/>
    

    3、编写IDUtils工具类

    import org.junit.Test;
    
    import java.util.UUID;
    
    @SuppressWarnings("all")//抑制警告
    public class IDutils {
        public static String getId(){
            return UUID.randomUUID().toString().replaceAll("-","");
    
        }
        @Test
        public void test(){
            System.out.println(IDutils.getId());
            System.out.println(IDutils.getId());
            System.out.println(IDutils.getId());
        }
    }
    

    4、编写实体类

    @Data
    public class Blog {
        private int id;
        private String title;
        private String author;
        private Date createTime;
        private int views;
    }
    

    5、编写实体类对应Mapper接口和Mapper.XML文件

    Mapper接口

    import com.kuang.pojo.Blog;
    
    import java.util.List;
    import java.util.Map;
    
    public interface BlogMapper {
        //插入数据
        int addBlog(Blog blog);
    
        //查询博客
        List<Blog> queryBlogIF(Map map);
    
        List<Blog> queryBlogChoose(Map map);
    
        //更新博客
        int updateBlog(Map map);
    
        //查询第1.2.3号记录的博客
        List<Blog> queryBlogForeach(Map map);
    }
    

    6、测试类

    import com.kuang.dao.BlogMapper;
    import com.kuang.pojo.Blog;
    import com.kuang.utils.IDutils;
    import com.kuang.utils.MybatisUtils;
    import org.apache.ibatis.session.SqlSession;
    import org.junit.Test;
    
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.List;
    
    public class MyTest {
        @Test
        public void addInitBlog(){
            SqlSession sqlSession = MybatisUtils.getSqlSession();
            BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
            Blog blog = new Blog();
            blog.setId(IDutils.getId());
            blog.setTitle("Mybatis如此简单");
            blog.setAuthor("狂神说");
            blog.setCreateTime(new Date());
            blog.setViews(9999);
    
            mapper.addBlog(blog);
    
            blog.setId(IDutils.getId());
            blog.setTitle("Java如此简单");
            mapper.addBlog(blog);
    
            blog.setId(IDutils.getId());
            blog.setTitle("Spring如此简单");
            mapper.addBlog(blog);
    
            blog.setId(IDutils.getId());
            blog.setTitle("微服务如此简单");
            mapper.addBlog(blog);
    
            sqlSession.close();
        }
    
        @Test
        public void queryBlogIF(){
            SqlSession sqlSession = MybatisUtils.getSqlSession();
            BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    
            HashMap map = new HashMap();
            map.put("title","Java如此简单");
            map.put("author","狂神说");
    
            List<Blog> blogs = mapper.queryBlogIF(map);
            for (Blog blog : blogs) {
                System.out.println(blog);
            }
    
            sqlSession.close();
        }
    
        @Test
        public void queryBlogChoose(){
            SqlSession sqlSession = MybatisUtils.getSqlSession();
            BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    
            HashMap map = new HashMap();
            map.put("title","Java如此简单");
            map.put("author","狂神说");
            map.put("views",9999);
    
            List<Blog> blogs = mapper.queryBlogChoose(map);
            for (Blog blog : blogs) {
                System.out.println(blog);
            }
    
            sqlSession.close();
        }
    
        @Test
        public void queryBlogSet(){
            SqlSession sqlSession = MybatisUtils.getSqlSession();
            BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    
            HashMap map = new HashMap();
            //map.put("title","Java如此简单2");
            map.put("author","狂神说2");
            map.put("id","3879c36d027e4681a23939106d46ab18");
    
            mapper.updateBlog(map);
    
            sqlSession.close();
        }
    
        @Test
        public void queryBlogForeach(){
            SqlSession sqlSession = MybatisUtils.getSqlSession();
            BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    
            HashMap map = new HashMap();
            ArrayList<Integer> ids = new ArrayList<Integer>();
            ids.add(1);
            ids.add(2);
    
            map.put("ids",ids);
            List<Blog> blogs = mapper.queryBlogForeach(map);
            for (Blog blog : blogs) {
                System.out.println(blog);
            }
    
            sqlSession.close();
    
        }
    }
    

    IF

    <select id="queryBlogIF" parameterType="map" resultType="blog">
        select * from blog where 1=1
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </select>
    

    choose (when, otherwise)

    从多个条件中选择一个使用。针对这种情况,MyBatis 提供了 choose 元素,它有点像 Java 中的 switch 语句。

    <select id="queryBlogChoose" parameterType="map" resultType="blog">
        select * from blog
        <where>
            <choose>
                <when test="title != null">
                    title = #{title}
                </when>
                <when test="author != null">
                    and author = #{author}
                </when>
                <otherwise>
                    and views = #{views}
                </otherwise>
            </choose>
        </where>
    </select>
    

    trim (where, set)

    where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且,若子句的开头为 “AND” 或 “OR”,where 元素也会将它们去除。

    <where>
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </where>
    

    set 元素会动态地在行首插入 SET 关键字,并会删掉额外的逗号(这些逗号是在使用条件语句给列赋值时引入的)。

    <update id="updateBlog" parameterType="map">
        update blog
        <set>
            <if test="title != null">
                title = #{title},
            </if>
            <if test="author!=null">
                author = #{author}
            </if>
        </set>
        where id = #{id}
    </update>
    

    Foreach

    select * from user where 1=1 and (id=1 or id=2 or id=3)
    
      <foreach item="id" collection="ids"
          open="(" separator="or" close=")">
            #{id}
      </foreach>
    
    

    在这里插入图片描述

    在这里插入图片描述

    <select id="queryBlogForeach" parameterType="map" resultType="blog">
        select * from blog
        <where>
            <foreach collection="ids" item="id" open="and (" separator="or" close=")">
                id = #{id}
            </foreach>
        </where>
    </select>
    

    测试类

    @Test
    public void queryBlogForeach(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    
        HashMap map = new HashMap();
        ArrayList<Integer> ids = new ArrayList<Integer>();
        ids.add(1);
        ids.add(2);
    
        map.put("ids",ids);
        List<Blog> blogs = mapper.queryBlogForeach(map);
        for (Blog blog : blogs) {
            System.out.println(blog);
        }
    
        sqlSession.close();
    
    }
    

    SQL片段

    有的时候,我们可能会将一些功能的部分抽取出来,方便复用

    1、使用SQL标签抽取公共部分

    <sql id="if-title-author">
        <if test="title != null">
            title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </sql>
    

    2、在需要的地方使用include标签引用即可

    <select id="queryBlogIF" parameterType="map" resultType="blog">
        select * from blog
        <where>
            <include refid="if-title-author"></include>
        </where>
    </select>
    

    注意事项:

    • 最好基于单表来定义SQL片段!

    • 不要存在where标签

    展开全文
  • Mybatis动态SQL解析

    万次阅读 2022-07-20 15:40:45
    由于前台传入的查询参数不同,所以写了很多的ifelse,还需要非常注意SQL语句里面的and、空格、逗号和转移的单引号这些,拼接和调试SQL就是...MyBaits的动态SQL就帮助我们解决了这个问题,它是基于OGNL表达式的。......

    1 为什么需要动态SQL?

    看一段Oracle存储过程代码:
    在这里插入图片描述
    由于前台传入的查询参数不同,所以写了很多的if else,还需要非常注意SQL语句里面的and、空格、逗号和转移的单引号这些,拼接和调试SQL就是一件非常耗时的工作。
    MyBaits的动态SQL就帮助我们解决了这个问题,它是基于OGNL表达式的。

    2 动态标签有哪些?

    按照官网的分类,MyBatis 的动态标签主要有四类:

    • if
    • choose (when, otherwise)
    • trim (where, set)
    • foreach

    3 举例说明

    if

    需要判断的时候,条件写在test中:

        <!-- 动态SQL where 和 if  -->
        <select id="selectBlogListIf" parameterType="blog" resultMap="BaseResultMap" >
            select bid, name, author_id authorId from blog
            <where>
                <if test="bid != null">
                    AND bid = #{bid}
                </if>
                <if test="name != null and name != ''">
                    AND name LIKE '%${name}%'
                </if>
                <if test="authorId != null">
                    AND author_id = #{authorId}
                </if>
            </where>
        </select>
    

    choose (when, otherwise)

    需要选择—个条件的时候:

        <!-- 动态SQL choose -->
        <select id="selectBlogListChoose" parameterType="blog" resultMap="BaseResultMap" >
            select bid, name, author_id authorId from blog
            <where>
                <choose>
                    <when test="bid !=null">
                        bid = #{bid, jdbcType=INTEGER}
                    </when>
                    <when test="name != null and name != ''">
                        AND name LIKE CONCAT(CONCAT('%', #{name, jdbcType=VARCHAR}),'%')
                    </when>
                    <when test="authorId != null ">
                        AND author_id = #{authorId, jdbcType=INTEGER}
                    </when>
                    <otherwise>
                    </otherwise>
                </choose>
            </where>
        </select>
    

    trim (where, set)

    需要去掉where, and、逗号之类的符号的时候:

        <!-- 动态SQL set -->
        <update id="updateByPrimaryKey" parameterType="blog">
            update blog
            <set>
                <if test="name != null">
                    name = #{name,jdbcType=VARCHAR},
                </if>
                <if test="authorId != null">
                    author_id = #{authorId,jdbcType=CHAR},
                </if>
            </set>
            where bid = #{bid,jdbcType=INTEGER}
        </update>
    

    用来指定或者去掉前缀或者后缀:

        <insert id="insertBlog" parameterType="blog">
        insert into blog
            <trim prefix="(" suffix=")" suffixOverrides=",">
                <if test="bid != null">
                    bid,
                </if>
                <if test="name != null">
                    name,
                </if>
                <if test="authorId != null">
                    author_id,
                </if>
            </trim>
            <trim prefix="values (" suffix=")" suffixOverrides=",">
                <if test="bid != null">
                    #{bid,jdbcType=INTEGER},
                </if>
                <if test="name != null">
                    #{name,jdbcType=VARCHAR},
                    <!-- #{name,jdbcType=VARCHAR,typeHandler=com.gupaoedu.type.MyTypeHandler}, -->
                </if>
                <if test="authorId != null">
                    #{authorId,jdbcType=INTEGER},
                </if>
            </trim>
        </insert>
    

    foreach

    需要遍历集合的时候:

        <!-- foreach 动态SQL 批量删除 -->
        <delete id="deleteByList" parameterType="java.util.List">
            delete from blog where bid in
            <foreach collection="list" item="item" open="(" separator="," close=")">
                #{item.bid,jdbcType=INTEGER}
            </foreach>
        </delete>
    
    展开全文
  • Mybatis 动态SQL

    千次阅读 2022-04-02 16:07:52
    Mybatis 动态SQL 一 .动态SQL 数组 array 使用foreach 标签 <!-- mybatis的集合操作 知识点: 如果遇到集合参数传递,需要将集合遍历 标签: foreach 循环遍历集合 标签属性说明: 1.collection 表示遍历...
  • mybatis_动态SQL

    千次阅读 2022-04-18 18:30:59
    动态sql是指sql语句可动态的变化 /** * 通过条件查询员工信息【条件不确定】 private Integer id; //员工id private String lastName; //员工姓名 private String email; //员工邮箱 private Double salary; ...
  • MyBatis动态SQL详解

    千次阅读 2021-11-24 10:21:59
    MyBatis动态SQL
  • 相比于原生的JDBC那一套,通过MyBatis确实解决了不少硬编码的问题**但是用户的查询永远是动态的操作,他可能在多个条件中选择其中少量条件进行查询,我们的SQL是死的,而用户需求对应的SQL却是活的,这样就会造成不...
  • MyBatis 注解实现动态SQL

    千次阅读 2022-03-12 10:36:54
    在 Mybatis 中,使用注解可以很方便的进行sql操作,但很多动态 SQL 都是由 xml 配置实现的。而随着 SpringBoot的逐渐发展,越来越多的配置由配置文件转成注解的形式。其中包括动态 SQL 。 Mybatis 的注解中,使用太...
  • mybatis之动态sql(超详细)

    千次阅读 2021-12-14 12:04:00
    动态SQL 可以根据具体的参数条件,来对SQL语句进行动态拼接。 比如在以前的开发中,由于不确定查询参数是否存在,许多人会使用类似于where 1 = 1来作为前缀,然后后面用AND拼接要查询的参数,这样,就算要查询的参数...
  • 动态sql与静态sql的区别

    千次阅读 2021-08-13 22:11:43
    首先,所谓SQL动态和静态,是指SQL语句在何时被编译和执行,二者都是用在SQL嵌入式编程中的,这里所说的嵌入式是指将SQL语句嵌入在高级语言中,而不是针对于单片机的那种嵌入式编程。 静态SQL,在编译阶段就可以...
  • 通过示例学习kettle动态查询,可以使用问号占位符或命名参数,并详细说明两者的区别。
  • mybatis-plus动态sql

    千次阅读 2022-02-15 23:50:14
    public class User { private Long id; private String name; private Integer age; private String email; } @Test public void testUpdate(){ ... //注意:update时生成的sql自动是动态sql
  • 1、Mybatis 动态 sql 可以让我们在 Xml 映射文件内,以标签的形式编写动态 sql,完成逻辑判断和动态拼接 sql 的功能。 2、Mybatis 提 供 了 9 种 动 态 sql 标 签 : trim|where|set|foreach|if|choose|when|...
  • 动态SQL(拼接)

    千次阅读 2021-01-19 16:04:56
    Q1:什么是动态SQL呢?A1:首先是SQL语句,是根据条件来拼接SQLQ2:为什么要用动态SQL?A2:因为在条件WHERE中出现OR会导致不能使用索引,从而使效率差别巨大。例如:如图1、2,图(1)图(2)Q3:怎么样使用动态SQL?A3...
  • Mybatis:动态SQL分组查询

    千次阅读 2020-08-19 14:27:41
    利用Mybatis 动态SQL 拼装Group By 语句,实现单个和多个字段分组 2. 代码实现 2.1 mapper <!--分组查询证书信息列表--> <resultMap id="groupResultMap" type="java.util.Map"> <result ...
  • 动态sql 动态sql : sql的内容是变化的,可以根据条件获取到不同的sql语句。 主要是where部分发生变化。 动态 SQL,主要用于解决查询条件不确定的情况:在程序运行期间,根据用户提交的查询条件进行查询。提交的查询...
  • Mybatis动态SQL的使用案例(实战Demo)

    千次阅读 2021-02-24 21:29:05
    【辰兮要努力】:hello你好我是辰兮,很高兴你能来阅读,昵称是希望自己能不断精进,向着优秀...文章目录一、文章序言二、实例应用1、动态SQL:if+where 语句2、动态SQL:if+set 语句 一、文章序言 开局分享一波干.
  • mybatis动态sql模糊查询方法

    千次阅读 2022-03-09 10:17:50
    动态SQL可以省略很多拼接SQL的步骤,使用类似于JSTL方式。 方式1 : <select id="queryBlogIf" resultType="blog" parameterType="map"> select * from mybatis.blog where 1 = 1 <if test="title!=...
  • Mybatis动态SQL的实现

    万次阅读 多人点赞 2019-02-27 19:28:42
    Mybatis提供了动态SQL,也就是可以根据用户提供的参数,动态决定查询语句依赖的查询条件或SQL语句的内容。 动态SQL标签 if 和 where 标签 &amp;lt;!--动态Sql : where / if--&amp;gt; &amp;lt;select ...
  • 1.Mybatis动态sql是做什么的?都有哪些动态sql?简述一下动态sql的执行原理? 1.动态SQL的概念 ​ 动态sql是指在进行sql操作的时候,传入的参数对象或者参数值,根据匹配的条件,有可能需要动态的去判断是否为空,...
  • Postgresql实现动态SQL语句

    千次阅读 2021-02-09 17:14:31
    本文介绍Postgresql如何实现动态SQL语句。 1. 动态SQL 动态SQL在程序启动时会根据输入参数替换相应变量。使用动态SQL可以创建更强大和灵活的应用程序,但在编译时SQL语句的全文不确定,因此运行时编译会牺牲一些性能...
  • 自定义动态SQL标签(易用,效率高)

    千次阅读 2022-03-18 19:40:08
    1.List, Set转SQL in 定义的sql: select * from orders where userid in #{userid @in} Java代码: Map<String, Object> map = new HashMap<>(); List<String> list=new ArrayList...
  • oralce中for执行动态sql

    千次阅读 2021-05-07 07:34:51
    --oralce中 for 执行动态sqlCREATE OR REPLACE FUNCTION fun_checkguaranteetype(TranId varchar2)return varchar2 is V_result varchar2(1000);Begindeclarezhiyavar NUMBER;diyavar NUMBER;dabaoren NUMBER;v_sql ...
  • SQLServer 执行动态SQL语句

    千次阅读 2019-09-22 17:04:38
    执行动态SQL语句 首先定义变量 @Games 为运动会名称, 为动态SQL语句定义变量 然后建立动态的SQL语句 最后运行这个动态的SQL语句 EXEC (@SQL2) 或 Exec SP_ExecuteSQL @SQL2 -- 执行动态SQL语句示例,复制后可直接...
  • Mybatis动态SQL原理解析

    千次阅读 2020-03-09 23:55:41
    首先翻阅官网文档,(https://mybatis.org/mybatis-3/dynamic-sql.html)这页文档首先描述了Mybatis的动态SQL是多么牛逼,解决了哪些问题,又讲了如何使用,而我们想知道他是如何实现的,所以这不是我们想要的。...
  • 什么是动态 SQL

    千次阅读 2020-10-07 14:48:24
    动态SQL,即通过MyBatis 提供的各种标签对条件作出判断已实现动态拼接SQL语句。条件判断使用的表达式为IGNL表达式。常用的动态标签有如下 < if > < where> < choose > 以及 < foreach> 等等...
  • Mybatis 注解开发 + 动态SQL

    千次阅读 2022-03-27 20:26:31
    Hello 大家好我是橙子同学,今天分享注解Mybatis注解开发+动态sql 目录 每文一铺垫(今天有小插曲哦) 注解开发 添加@Insert 删除@Delete 查询@Select 修改@Update 实现结果集封装@Result 实现一对一结果...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 556,599
精华内容 222,639
关键字:

动态sql

友情链接: 路由器基础配置.rar