用到了wrapper,ge、le、ne、eq等的用法,及多表查询自写sql整理资料记录一下,以备后续复习。

目录------------(可点击相应目录直接跳转)

一、条件构造器关系介绍

条件构造器关系介绍 :

wapper介绍 :

二、项目实例

1、根据主键或者简单的查询条件进行查询

2、MyBatis-Plus还提供了Wrapper条件构造器,具体使用看如下代码:

三、具体使用操作

1、ge、gt、le、lt、isNull、isNotNull

2、eq、ne

3、between、notBetween

4、allEq

5、like、notLike、likeLeft、likeRight

6、in、notIn、inSql、notinSql、exists、notExists

7、or、and

8、嵌套or、嵌套and

9、orderBy、orderByDesc、orderByAsc

10、last

11、指定要查询的列

12、set、setSql

四、项目中实际应用代码实例

实例1--包含 eq相等的比较方法

 实例2--包含 ge le ge等比较方法,及分页查询方法

 实例3--多表查询,手写sql示例,五表联查

先了解一下内外连接:

SQL内连接(INNER JOIN)

SQL外连接(OUTER JOIN


一、条件构造器关系介绍

条件构造器关系介绍 :

上图绿色框为抽象类abstract
蓝色框为正常class类,可new对象
黄色箭头指向为父子类关系,箭头指向为父类


wapper介绍 :

Wrapper : 条件构造抽象类,最顶端父类

AbstractWrapper : 用于查询条件封装,生成 sql 的 where 条件

QueryWrapper : Entity 对象封装操作类,不是用lambda语法

UpdateWrapper : Update 条件封装,用于Entity对象更新操作

AbstractLambdaWrapper : Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。

LambdaQueryWrapper :看名称也能明白就是用于Lambda语法使用的查询Wrapper

 LambdaUpdateWrapper : Lambda 更新封装Wrapper

二、项目实例


1、根据主键或者简单的查询条件进行查询

    /**
     * 通过单个ID主键进行查询
     */
    @Test
    public void selectById() {
        User user = userMapper.selectById(1094592041087729666L);
        System.out.println(user);
    }
 
    /**
     * 通过多个ID主键查询
     */
    @Test
    public void selectByList() {
        List<Long> longs = Arrays.asList(1094592041087729666L, 1094590409767661570L);
        List<User> users = userMapper.selectBatchIds(longs);
        users.forEach(System.out::println);
    }
 
    /**
     * 通过Map参数进行查询
     */
    @Test
    public void selectByMap() {
        Map<String, Object> params = new HashMap<>();
        params.put("name", "张雨琪");
        List<User> users = userMapper.selectByMap(params);
        users.forEach(System.out::println);
    }

2、MyBatis-Plus还提供了Wrapper条件构造器,具体使用看如下代码:

/**
     * 名字包含雨并且年龄小于40
     * <p>
     * WHERE name LIKE '%雨%' AND age < 40
     */
    @Test
    public void selectByWrapperOne() {
        QueryWrapper<User> wrapper = new QueryWrapper();
        wrapper.like("name", "雨").lt("age", 40);
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }
 
    /**
     * 名字包含雨
     * 年龄大于20小于40
     * 邮箱不能为空
     * <p>
     * WHERE name LIKE '%雨%' AND age BETWEEN 20 AND 40 AND email IS NOT NULL
     */
    @Test
    public void selectByWrapperTwo() {
        QueryWrapper<User> wrapper = Wrappers.query();
        wrapper.like("name", "雨").between("age", 20, 40).isNotNull("email");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }
 
    /**
     * 名字为王性
     * 或者年龄大于等于25
     * 按照年龄降序排序,年龄相同按照id升序排序
     * <p>
     * WHERE name LIKE '王%' OR age >= 25 ORDER BY age DESC , id ASC
     */
    @Test
    public void selectByWrapperThree() {
        QueryWrapper<User> wrapper = Wrappers.query();
        wrapper.likeRight("name", "王").or()
                .ge("age", 25).orderByDesc("age").orderByAsc("id");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }
 
    /**
     * 查询创建时间为2019年2月14
     * 并且上级领导姓王
     * <p>
     * WHERE date_format(create_time,'%Y-%m-%d') = '2019-02-14' AND manager_id IN (select id from user where name like '王%')
     */
    @Test
    public void selectByWrapperFour() {
        QueryWrapper<User> wrapper = Wrappers.query();
        wrapper.apply("date_format(create_time,'%Y-%m-%d') = {0}", "2019-02-14")
                .inSql("manager_id", "select id from user where name like '王%'");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }
 
    /**
     * 查询王姓
     * 并且年龄小于40或者邮箱不为空
     * <p>
     * WHERE name LIKE '王%' AND ( age < 40 OR email IS NOT NULL )
     */
    @Test
    public void selectByWrapperFive() {
        QueryWrapper<User> wrapper = Wrappers.query();
        wrapper.likeRight("name", "王").and(qw -> qw.lt("age", 40).or().isNotNull("email"));
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }
 
    /**
     * 查询王姓
     * 并且年龄大于20 、年龄小于40、邮箱不能为空
     * <p>
     * WHERE name LIKE ? OR ( age BETWEEN ? AND ? AND email IS NOT NULL )
     */
    @Test
    public void selectByWrapperSix() {
        QueryWrapper<User> wrapper = Wrappers.query();
        wrapper.likeRight("name", "王").or(
                qw -> qw.between("age", 20, 40).isNotNull("email")
        );
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }
 
    /**
     * (年龄小于40或者邮箱不为空) 并且名字姓王
     * WHERE ( age < 40 OR email IS NOT NULL ) AND name LIKE '王%'
     */
    @Test
    public void selectByWrapperSeven() {
        QueryWrapper<User> wrapper = Wrappers.query();
        wrapper.nested(qw -> qw.lt("age", 40).or().isNotNull("email"))
                .likeRight("name", "王");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }
 
    /**
     * 查询年龄为30、31、32
     * WHERE age IN (?,?,?)
     */
    @Test
    public void selectByWrapperEight() {
        QueryWrapper<User> wrapper = Wrappers.query();
        wrapper.in("age", Arrays.asList(30, 31, 32));
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }
 
    /**
     * 查询一条数据
     * limit 1
     */
    @Test
    public void selectByWrapperNine() {
        QueryWrapper<User> wrapper = Wrappers.query();
        wrapper.in("age", Arrays.asList(30, 31, 32)).last("limit 1");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

三、具体使用操作

注意:以下条件构造器的方法入参中的 column 均表示数据库字段

1、ge、gt、le、lt、isNull、isNotNull


@Test
public void testDelete() {
 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper
        .isNull("name")
        .ge("age", 12)
        .isNotNull("email");
    int result = userMapper.delete(queryWrapper);
    System.out.println("delete return count = " + result);
}


SQL:UPDATE user SET deleted=1 WHERE deleted=0 AND name IS NULL AND age >= ? AND email IS NOT NULL

2、eq、ne


注意:seletOne返回的是一条实体记录,当出现多条时会报错

@Test
public void testSelectOne() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("name", "Tom");
 
    User user = userMapper.selectOne(queryWrapper);
    System.out.println(user);
}


3、between、notBetween


包含大小边界

@Test
public void testSelectCount() {
 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.between("age", 20, 30);
 
    Integer count = userMapper.selectCount(queryWrapper);
    System.out.println(count);
}

SELECT COUNT(1) FROM user WHERE deleted=0 AND age BETWEEN ? AND ? 

4、allEq

@Test
public void testSelectList() {
 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    Map<String, Object> map = new HashMap<>();
    map.put("id", 2);
    map.put("name", "Jack");
    map.put("age", 20);9
 
    queryWrapper.allEq(map);
    List<User> users = userMapper.selectList(queryWrapper);
 
    users.forEach(System.out::println);
}

SELECT id,name,age,email,create_time,update_time,deleted,version FROM user WHERE deleted=0 AND name = ? AND id = ? AND age = ? 

5、like、notLike、likeLeft、likeRight


selectMaps返回Map集合列表

@Test
public void testSelectMaps() {
 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper
        .notLike("name", "e")
        .likeRight("email", "t");
 
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);//返回值是Map列表
    maps.forEach(System.out::println);
}

SELECT id,name,age,email,create_time,update_time,deleted,version FROM user WHERE deleted=0 AND name NOT LIKE ? AND email LIKE ? 

6、in、notIn、inSql、notinSql、exists、notExists


in、notIn:

notIn("age",{1,2,3})--->age not in (1,2,3)
notIn("age", 1, 2, 3)--->age not in (1,2,3)

inSql、notinSql:可以实现子查询

例: inSql("age", "1,2,3,4,5,6")--->age in (1,2,3,4,5,6)
例: inSql("id", "select id from table where id < 3")--->id in (select id from table where id < 3)
@Test
public void testSelectObjs() {
 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //queryWrapper.in("id", 1, 2, 3);
    queryWrapper.inSql("id", "select id from user where id < 3");
 
    List<Object> objects = userMapper.selectObjs(queryWrapper);//返回值是Object列表
    objects.forEach(System.out::println);
}

SELECT id,name,age,email,create_time,update_time,deleted,version FROM user WHERE deleted=0 AND id IN (select id from user where id < 3) 

7、or、and


注意:这里使用的是 UpdateWrapper 不调用or则默认为使用 and 连

@Test
public void testUpdate1() {
 
    //修改值
    User user = new User();
    user.setAge(99);
    user.setName("Andy");
 
    //修改条件
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    userUpdateWrapper
        .like("name", "h")
        .or()
        .between("age", 20, 30);
 
    int result = userMapper.update(user, userUpdateWrapper);
    System.out.println(result);
}

UPDATE user SET name=?, age=?, update_time=? WHERE deleted=0 AND name LIKE ? OR age BETWEEN ? AND ?

8、嵌套or、嵌套and


这里使用了lambda表达式,or中的表达式最后翻译成sql时会被加上圆括号

@Test
public void testUpdate2() {
 
    //修改值
    User user = new User();
    user.setAge(99);
    user.setName("Andy");
 
    //修改条件
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    userUpdateWrapper
        .like("name", "h")
        .or(i -> i.eq("name", "李白").ne("age", 20));
 
    int result = userMapper.update(user, userUpdateWrapper);
    System.out.println(result);
}


UPDATE user SET name=?, age=?, update_time=? 

WHERE deleted=0 AND name LIKE ? 

OR ( name = ? AND age <> ? ) 

9、orderBy、orderByDesc、orderByAsc
 

@Test
public void testSelectListOrderBy() {
 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.orderByDesc("id");
 
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

SELECT id,name,age,email,create_time,update_time,deleted,version 

FROM user WHERE deleted=0 ORDER BY id DESC

10、last


直接拼接到 sql 的最后

注意:只能调用一次,多次调用以最后一次为准 有sql注入的风险,请谨慎使用

@Test
public void testSelectListLast() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.last("limit 1");
 
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}


SELECT id,name,age,email,create_time,update_time,deleted,version 

FROM user WHERE deleted=0 limit 1

11、指定要查询的列

@Test
public void testSelectListColumn() {
 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.select("id", "name", "age");
 
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

SELECT id,name,age FROM user WHERE deleted=0

12、set、setSql


最终的sql会合并 user.setAge(),以及 userUpdateWrapper.set()  和 setSql() 中 的字段

@Test
public void testUpdateSet() {
    //修改值
    User user = new User();
    user.setAge(99);
 
    //修改条件
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    userUpdateWrapper
        .like("name", "h")
        .set("name", "老李头")//除了可以查询还可以使用set设置修改的字段
        .setSql(" email = '123@qq.com'");//可以有子查询
    int result = userMapper.update(user, userUpdateWrapper);
}


UPDATE user SET age=?, update_time=?, name=?, email = '123@qq.com' WHERE deleted=0 AND name LIKE ?

四、项目中实际应用代码实例

(此部分更新于2022年7月20日)

实例1--包含 eq相等的比较方法

 实例2--包含 ge le ge等比较方法,及分页查询方法

 实例3--多表查询,手写sql示例,五表联查

先了解一下内外连接:

什么是连接表?
多表查询原理:将多个表通过笛卡尔积形成一个虚表,再根据查询条件筛选符合条件的数据。
在关系数据库中,数据分布在多个逻辑表中。 要获得完整有意义的数据集,需要使用连接来查询这些表
中的数据。 SQL Server支持多种
连接包括
INNER JOIN:内连接,关键字在表中存在至少一个匹配时返回行。
left join : 左连接,返回左表中所有的记录以及右表中连接字段相等的记录。
right join : 右连接,返回右表中所有的记录以及左表中连接字段相等的记录。
inner join : 内连接,又叫等值连接,只返回两个表中连接字段相等的行。
full join : 外连接,返回两个表中的行:left join + right join。
cross join : 结果是笛卡尔积,就是第一个表的行数乘以第二个表的行数。
GROUP BY:全外连接, 子句必须放在 WHERE 子句中的条件之后,必须放在 ORDER BY 子句之前
每种连接类型指定SQL Server如何使用一个表中的数据来选择另一个表中的行
 

SQL内连接(INNER JOIN)


  返回两张表中符合连接条件的数据行

   内连接是从结果表中删除与被连接表中未匹配行的所有行,所以内连接可能会丢失信息


SQL外连接(OUTER JOIN)


    外连接(OUTER JOIN)分 为左连接、右连接和全连接
    

    左连接:返回左表中的所以行,如果左表中行在右表中没有匹配行,则结果中右表中的列返回空值NULL

 

     语法:SELECT * FROM 表1 LEFT OUTER JOIN 表2 ON 条件
    eg:我们左连接Student表、Score表查询学生的成绩,SQL 语句如下:
    SELECT * FROM Student LEFT OUTER JOIN Score ON Student.id = Score.studentID


    右 连 接:返回右表中的所以行,如果右表中行在左表中没有匹配行,则结果中左表中的列返回空值NULL

 

     语法:SELECT * FROM 表1 RIGHT OUTER JOIN 表2 ON 条件
    eg:我们右连接Student表、Score表查询学生的成绩,SQL 语句如下:
    SELECT * FROM Student RIGHT OUTER JOIN Score ON Student.id = Score.studentID
 


    全连接:返回左表和右表中的所有行,当某行在另一表中没有匹配行,则另一表中的补NULL
 
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

这个是mybatis-plus插件中mapper的一个表查询写法,由多个表内连接或外连接组成的数据。

用到的表结构如下: 分别为问题库表、数据字典、数据字典类型、部门表、用户表

 数据示例如下:obdis_problem表里去查type字段内容并返回对应的汉字语义

 

 查询每个字段都进行一次表连接,拿到对应的值,得出一个表结果值,即A\B\C\D等等结果,最后拼起来返回前端展示即可。搞懂了这个,所有的多表查询就基本迎刃而解。

<!-- 问题库列表返回与查询-->
    <select id="searchMoreProblem" resultType="com.hollysys.obdis.vo.problem.SearchObdisProblem">
      select
        p.id ,
        p.level,
        A.dict_value as level_text,
        p.dept_id_mgr,
        B.org_name as deptIdMgr_text,
        p.dept_id_work,
        C.org_name as deptIdWork_text,
        p.station,
        D.dict_value as station_text,
        p.source,
        E.dict_value as source_text,
        p.categroy,
        F.dict_value as categroy_text,
        p.type,
        G.dict_value as type_text,
        p.dev_code,
        H.dict_value as devCode_text,
        p.check_time,
        p.check_user,
        I.username as checkUser_text,
        p.deadline,
        p.deadline_real,
        p.duty_user,
        J.username as dutyUser_text,
        p.correct_user,
        K.username as correctUser_text,
        p.state,
        p.problem,
        p.requirement,
        p.solution
        from
        obdis_problem   p
        left join t_dict A on p.level = A.id
        left join t_dept B on p.dept_id_mgr = B.org_id
        left join t_dept C on p.dept_id_work = C.org_id
        left join t_dict D on p.station = D.id
        left join t_dict E on p.source = E.id
        left join t_dict F on p.categroy = F.id
        left join t_dict G on p.type = G.id
        left join t_dict H on p.dev_code = H.id
        left join t_user I on p.check_user = I.user_id
        left join t_user J on p.duty_user = J.user_id
        left join t_user K on p.correct_user = K.user_id

    where 1=1
      <if test="searchObdisProblem.levelText != null and searchObdisProblem.levelText != ''">
       and A.dict_value like concat('%', #{searchObdisProblem.levelText}, '%')
      </if>
      <if test="searchObdisProblem.deptIdMgrText != null and searchObdisProblem.deptIdMgrText != ''">
       and B.org_name like concat('%', #{searchObdisProblem.deptIdMgrText}, '%')
      </if>
      <if test="searchObdisProblem.deptIdWorkText != null and searchObdisProblem.deptIdWorkText != '' ">
       and C.org_name like concat('%', #{searchObdisProblem.deptIdWorkText}, '%')
      </if>
      <if test="searchObdisProblem.stationText != null and searchObdisProblem.stationText != ''">
        and D.dict_value = #{searchObdisProblem.stationText}
      </if>
      <if test="searchObdisProblem.sourceText != null and searchObdisProblem.sourceText != ''">
       and E.dict_value = #{searchObdisProblem.sourceText}
      </if>
      <if test="searchObdisProblem.categroyText != null  and searchObdisProblem.categroyText != ''">
        and F.dict_value = #{searchObdisProblem.categroyText}
      </if>
      <if test="searchObdisProblem.typeText != null  and searchObdisProblem.typeText != ''">
        and G.dict_value = #{searchObdisProblem.typeText}
      </if>
      <if test="searchObdisProblem.devCodeText != null and searchObdisProblem.devCodeText != ''">
        and H.dict_value = #{searchObdisProblem.devCodeText}
      </if>
      <if test="searchObdisProblem.checkTimeStart != null ">
        and p.check_time &gt;= #{searchObdisProblem.checkTimeStart}
      </if>
        <if test="searchObdisProblem.checkTimeEnd != null ">
            and p.check_time &lt;= #{searchObdisProblem.checkTimeEnd}
            order by p.check_time
        </if>
      <if test="searchObdisProblem.checkUserText != null and searchObdisProblem.checkUserText != ''">
        and I.username = #{searchObdisProblem.checkUserText}
      </if>
      <if test="searchObdisProblem.deadline != null ">
        and p.deadline = #{searchObdisProblem.deadline}
      </if>
      <if test="searchObdisProblem.deadlineReal != null ">
        and p.deadline_real = #{searchObdisProblem.deadlineReal}
      </if>
      <if test="searchObdisProblem.dutyUserText != null and searchObdisProblem.dutyUserText != ''">
        and J.username = #{searchObdisProblem.dutyUserText}
      </if>
      <if test="searchObdisProblem.correctUserText != null and searchObdisProblem.correctUserText != ''">
        and K.username = #{searchObdisProblem.correctUserText}
      </if>
      <if test="searchObdisProblem.state != null and searchObdisProblem.state != ''">
        and state = #{searchObdisProblem.state}
      </if>
      <if test="searchObdisProblem.problem != null and searchObdisProblem.problem != ''">
          and p.problem like concat('%', #{searchObdisProblem.problem}, '%')
      </if>
      <if test="searchObdisProblem.requirement != null and searchObdisProblem.requirement != ''">
          and p.requirement like concat('%', #{searchObdisProblem.requirement}, '%')
      </if>
      <if test="searchObdisProblem.solution != null and searchObdisProblem.solution != ''">
          and p.solution like concat('%', #{searchObdisProblem.solution}, '%')
      </if>
  </select>

-------------------------------------------------------------------------------------以下无正文-------------------

参考文档

1、(五)springboot + mybatis plus强大的条件构造器queryWrapper、updateWrapper_青蛙与大鹅的博客-CSDN博客_querywrapper.eq

2、https://blog.csdn.net/kepengs/article/details/112345870

3、Wrapper使用_weixin_39615889的博客-CSDN博客_wrapper使用

4、MyBatis-Plus Wrapper条件构造器查询大全_IT贱男的博客-CSDN博客_wrapper.like

 5、https://blog.csdn.net/qq_48209375/article/details/114446611

6、https://blog.csdn.net/TBDBTUO/article/details/123550498

Logo

为开发者提供学习成长、分享交流、生态实践、资源工具等服务,帮助开发者快速成长。

更多推荐