MyBatis Plus(六)

inSql 和 notInSql

1. MyBatis Plus 条件构造器提供了 inSql 和 notInSql,传递 SQL 语句给这两个方法，方法将自动执行 SQL 且将 SQL 的结果作为条件输入值

inSql（对应SQL中的 in 操作符）

inSql(R column, String inValue)
inSql(boolean condition, R column, String inValue)

2. 参数
   1. column：列名称
   2. inValue：查询 in 条件值的 SQL 语句
   3. condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件
3. 查询用户 ID 小于 10 的用户信息列表

QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
wrapper.inSql("user_id", "select user_id from user where user_id<10");

notInSql（对应SQL中的 not in 操作符）

notInSql(R column, String inValue)
notInSql(boolean condition, R column, String inValue)

1. 参数
   1. column：列名称
   2. inValue：查询 in 条件值的 SQL 语句
   3. condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件
2. 查询性别不是“男”或“女”的用户信息

QueryWrapper wrapper = new QueryWrapper<>();
wrapper.notInSql("user_id", "select user_id from user where sex in ('男','女')");

样例代码

 @Test
    void contextLoads() {
    
    
        QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
        wrapper.inSql("user_id", "select user_id from user where user_id<10");
        List<UserBean> userBeanList = simpleMapper.selectList(wrapper);
        for(UserBean userBean : userBeanList) {
    
    
            System.out.println(userBean);
        }
 
        wrapper = new QueryWrapper<>();
        wrapper.notInSql("user_id", "select user_id from user where sex in ('男','女')");
        userBeanList = simpleMapper.selectList(wrapper);
        for(UserBean userBean : userBeanList) {
    
    
            System.out.println(userBean);
        }
    }

排序 order by

1. orderByAsc、orderByDesc 和 orderBy 三个方法实现数据排序
   orderByAsc（实现递增排序）

orderByAsc(R... columns)
orderByAsc(boolean condition, R... columns)

2. 参数
   1. columns：列名称，可以指定多个
   2. condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件
3. 根据用户 ID 和 年龄递增排序。

QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
wrapper.orderByAsc("user_id", "age");

orderByDesc（实现递减排序）

orderByDesc(R... columns)
orderByDesc(boolean condition, R... columns)

2. 参数
   1. columns：列名称，可以指定多个
   2. condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件
3. 根据用户 ID 和 年龄递减排序

QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
wrapper.orderByDesc("user_id", "age");

orderBy（自定义排序方式）

orderBy(boolean condition, boolean isAsc, R... columns)

1. 参数
   1. columns：列名称，可以指定多个
   2. condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件
   3. isAsc：是否使用 ASC 排序，即递增排序；否则，则使用递减 （DESC）排序
2. 根据用户 ID 和 年龄递减排序

QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
wrapper.orderBy(true, false, "user_id", "age");

排序 order by样例代码

@Test
    void contextLoads() {
    
    
        QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
        wrapper.le("user_id", 10);
        wrapper.orderByAsc("user_id");
        List<UserBean> userBeanList = simpleMapper.selectList(wrapper);
        for(UserBean userBean : userBeanList) {
    
    
            System.out.println(userBean);
        }
 
        wrapper = new QueryWrapper<>();
        wrapper.le("user_id", 10);
        wrapper.orderByDesc("user_id");
        userBeanList = simpleMapper.selectList(wrapper);
        for(UserBean userBean : userBeanList) {
    
    
            System.out.println(userBean);
        }
    }

exists 和 notExists

exists（拼接 EXISTS sql语句 ）

exists(String existsSql)
exists(boolean condition, String existsSql)

1. 参数
   1. existsSql：exists SQL 语句
   2. condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件
2. 如果在 user_contact 中存在 user_id 等于 1 的记录，则返回 user 表的所有记录，只返回 user 表的 user_id 在 user_contact 表中存在的 user 记录

QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
wrapper.exists("select id from user_contact where user_id=1");

notExists（拼接 NOT EXISTS sql语句）

notExists(String notExistsSql)
notExists(boolean condition, String notExistsSql)

1. 参数说明
   1. notExistsSql：not exists SQL 语句
   2. condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件
2. 如果在 user_contact 表中不存在 user_id 等于 1 的记录，则返回 user 表中所有的记录

QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
wrapper.notExists("select id from user_contact where user_id=1");

exists 和 notExists样例

@Test
    void contextLoads() {
    
    
        QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
        wrapper.exists("select id from user_contact where user_id=1");
        List<UserBean> userBeanList = simpleMapper.selectList(wrapper);
        System.out.println("result size=" + userBeanList.size());
 
        wrapper = new QueryWrapper<>();
        wrapper.notExists("select id from user_contact where user_id=1");
        userBeanList = simpleMapper.selectList(wrapper);
        System.out.println("result size=" + userBeanList.size());
    }

last 追加SQL

1. 使用 last 方法在 SQL 后面添加一小段其他 SQL 语句
2. last 行数将无视 SQL 的优化规则，直接指定的 SQL 拼接到 SQL 的最后
3. last 函数只能调用一次，如果多次调用，以最后一次调用为准（有sql注入的风险,请谨慎使用
4. last 方法定义

last(String lastSql)
last(boolean condition, String lastSql)

5. 参数说明
   1. lastSql：要追加到 SQL 后面的 SQL 语句
   2. condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件。
6. 在 SQL 后面追加分页 SQL 语句。

QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
wrapper.last("limit 1,10");

last 追加SQL样例

@Test
    void contextLoads() {
    
    
        QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
        wrapper.last("limit 1,10");
        List<UserBean> userBeanList = simpleMapper.selectList(wrapper);
        System.out.println("result size=" + userBeanList.size());
    }

apply 拼接SQL

1. apply 方法用来拼接 SQL 语句用于动态的给数据库函数传入参数,并且可以避免 SQL 注入风险

apply("date_format(dateColumn,'%Y-%m-%d') = {0}", "2020-10-08")

2. apply 函数将使用后面的“2020-10-08”参数替换第一个参数中的{0}

apply 方法定义

apply(String applySql, Object... params)
apply(boolean condition, String applySql, Object... params)

1. 参数：
   1. applySql：要拼接的 SQL 语句，该 SQL 语句中可能会有 {0}、{1}、…、{n} 等字符串，用来替换参数
   2. params：参数列表，用于替换 applySql SQL 语句中的 {0}、{1}、…、{n} 等
   3. condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件。
2. 使用 apply 方法拼接 SQL 语句

// 拼接：id = 100
apply("id = 100");
 
// 拼接：date_format(dateColumn,'%Y-%m-%d') = '2018-08-08'")
apply("date_format(dateColumn,'%Y-%m-%d') = '2018-08-08'")
 
// 拼接：date_format(dateColumn,'%Y-%m-%d') = '2018-08-08'")
apply("date_format(dateColumn,'%Y-%m-%d') = {0}", "2018-08-08")

apply 拼接SQL样例

 @Test
    void contextLoads() {
    
    
        QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
        wrapper.apply("date_format(borthday,'%Y-%m-%d') = {0}", "1990-10-01");
 
        List<UserBean> userBeanList = simpleMapper.selectList(wrapper);
        System.out.println("result size=" + userBeanList.size());
    }
 

nested 嵌套SQL

1. nested 方法用于嵌套SQL

nested(Consumer<Param> consumer)
nested(boolean condition, Consumer<Param> consumer)

2. 参数
   1. consumer：构造内嵌SQL条件
   2. condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件。
3. 查询所有姓黄，性别为男，年龄大于 30，薪水大于 9000 的用户信息

QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
wrapper.likeRight("name", "黄");
wrapper.nested(new Consumer<QueryWrapper<UserBean>>() {
    
    
    @Override
    public void accept(QueryWrapper<UserBean> userBeanQueryWrapper) {
    
    
        userBeanQueryWrapper.eq("sex", "男")
                .gt("age", 30).gt("salary", 9000);
    }
});

nested 嵌套SQL样例

@Test
    void contextLoads() {
    
    
        QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
        wrapper.likeRight("name", "黄");
        wrapper.nested(new Consumer<QueryWrapper<UserBean>>() {
    
    
            @Override
            public void accept(QueryWrapper<UserBean> userBeanQueryWrapper) {
    
    
                userBeanQueryWrapper.eq("sex", "男")
                        .gt("age", 30).gt("salary", 9000);
            }
        });
 
        List<UserBean> userBeanList = simpleMapper.selectList(wrapper);
        System.out.println("result size=" + userBeanList.size());
    }

group by 分组

1. group by 分组函数定义

groupBy(R... columns)
groupBy(boolean condition, R... columns)

2. 参数
   1. columns：要分组的数据表列名称列表
   2. condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件。
3. 用户信息表根据 sex 和 age 列进行分组

QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
wrapper.groupBy("sex", "age");

group by 分组样例

1. 根据 sex 和 age 分组，然后统计他们的总薪水、用户数和平均薪水

 private void totalSalary() {
    
    
        QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
        wrapper.groupBy("sex", "age");
        wrapper.select("sex, age, sum(salary) as total_salary");
 
        List<UserBean> userBeanList = simpleMapper.selectList(wrapper);
        for(UserBean userBean : userBeanList) {
    
    
            System.out.println("sex=" + userBean.getSex() + ", age=" + userBean.getAge()
                    + ", totalSalary=" + userBean.getTotalSalary());
        }
    }
 
    private void totalCount() {
    
    
        QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
        wrapper.groupBy("sex", "age");
        wrapper.select("sex, age, count(*) as total_count");
 
        List<UserBean> userBeanList = simpleMapper.selectList(wrapper);
        for(UserBean userBean : userBeanList) {
    
    
            System.out.println("sex=" + userBean.getSex() + ", age=" + userBean.getAge()
                    + ", totalCount=" + userBean.getTotalCount());
        }
    }
 
    private void avgSalary() {
    
    
        QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
        wrapper.groupBy("sex", "age");
        wrapper.select("sex, age, avg(salary) as avg_salary");
 
        List<UserBean> userBeanList = simpleMapper.selectList(wrapper);
        for(UserBean userBean : userBeanList) {
    
    
            System.out.println("sex=" + userBean.getSex() + ", age=" + userBean.getAge()
                    + ", avgSalary=" + userBean.getAvgSalary());
        }
    }

or 和 and

1. or（或，拼接SQL的 OR 语句）

or()
or(boolean condition)

2. 参数
   1. condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件。
   2. 主动调用 or 表示紧接着下一个方法不是用 and 连接！（不调用or则默认为使用and连接）
3. 构建一个查询用户 id 等于1，或者用户名称为“张三”的查询条件

QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
wrapper.eq("id",1);
wrapper.or();
wrapper.eq("name","老王");

表示 “id = 1 or name = '老王'”。

or 嵌套

or(Consumer<Param> consumer)
or(boolean condition, Consumer<Param> consumer)

1. 参数
   1. consumer：构造查询条件的回调接口，你需要实现 accept 方法
   2. condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件。
2. 构造性别（sex）为 null，或者 sex=‘男’ 且 薪水在 5000~6000 之间的用户信息

QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
wrapper.isNull("sex");
wrapper.or(new Consumer<QueryWrapper<UserBean>>() {
    
    
    @Override
    public void accept(QueryWrapper<UserBean> userBeanQueryWrapper) {
    
    
        userBeanQueryWrapper.eq("sex", "男")
            .between("salary", 5000, 6000);
    }
});

and（与，and 嵌套）

and(Consumer<Param> consumer)
and(boolean condition, Consumer<Param> consumer)

1. 参数
   1. consumer：构造查询条件的回调接口，你需要实现 accept 方法
   2. condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件。
2. 构造 sex 等于“男”，薪水在 5000~6000之间，年龄大于30，且姓“黄”的用户信息

QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
wrapper.and(new Consumer<QueryWrapper<UserBean>>() {
    
    
    @Override
    public void accept(QueryWrapper<UserBean> userBeanQueryWrapper) {
    
    
        userBeanQueryWrapper.eq("sex", "男")
            .between("salary", 5000, 6000);
    }
});
 
wrapper.and(new Consumer<QueryWrapper<UserBean>>() {
    
    
    @Override
    public void accept(QueryWrapper<UserBean> userBeanQueryWrapper) {
    
    
        userBeanQueryWrapper.gt("age", 30)
            .likeRight("name", "黄");
    }
});