为知笔记
MybatisPlus-条件构造器
编辑
2024-11-14
实用工具
00
请注意，本文编写于 140 天前，最后修改于 140 天前，其中某些信息可能已经过时。

目录

功能详解
基本方法
allEq 全等
eq 相等
ne 不等
gt 大于
ge 大于等于
lt 小于
le 小于等于
between
notBetween
like
notLike
likeLeft 右模糊匹配
notLikeLeft 非右模糊匹配
likeRight 左模糊匹配
notLikeRight 非左模糊匹配
isNull 为空
isNotNull 不为空
in
notIn
or
and
高级方法
inSql-使用SQL生成IN子句中的值集合
示例
notInSql-使用SQL生成NOT IN子句中的值集合
示例
eqSql(since3.5.6)-字段和sql结果匹配
示例
结果
gtSql(since3.4.3.2)字段大于sql结果
示例
结果
geSql(since3.4.3.2)字段大于等于sql结果
示例
结果
ltSql(since3.4.3.2)字段小于sql结果
示例
结果
leSql(since3.4.3.2)字段小于等于sql结果
示例
结果
groupBy 分组
示例
结果
orderByAsc
示例
结果
orderByDesc
示例
结果
orderBy
结果
having
示例
结果
func 根据条件执行不同查询
示例
nested 创建独立的查询条件块
示例
apply 直接拼接SQL片段到查询语句
示例
last 直接在查询后面添加sql片段
示例
exists
示例
notExists
示例
select 设置查询的字段
示例
set
示例
setSql 将sql作为set子句添加更新
示例
setIncrBy（Since 3.5.6）递增指定的字段的值
示例
setDecrBy（Since 3.5.6）递减指定的字段的值
示例
lambda
示例

MyBatis-Plus 提供了一套强大的条件构造器（Wrapper），用于构建复杂的数据库查询条件。Wrapper 类允许开发者以链式调用的方式构造查询条件，无需编写繁琐的 SQL 语句，从而提高开发效率并减少 SQL 注入的风险。

在 MyBatis-Plus 中，Wrapper 类是构建查询和更新条件的核心工具。以下是主要的 Wrapper 类及其功能：

  • AbstractWrapper：这是一个抽象基类，提供了所有 Wrapper 类共有的方法和属性。它定义了条件构造的基本逻辑，包括字段（column）、值（value）、操作符（condition）等。所有的 QueryWrapper、UpdateWrapper、LambdaQueryWrapper 和 LambdaUpdateWrapper 都继承自 AbstractWrapper。

  • QueryWrapper：专门用于构造查询条件，支持基本的等于、不等于、大于、小于等各种常见操作。它允许你以链式调用的方式添加多个查询条件，并且可以组合使用 and 和 or 逻辑。

  • UpdateWrapper：用于构造更新条件，可以在更新数据时指定条件。与 QueryWrapper 类似，它也支持链式调用和逻辑组合。使用 UpdateWrapper 可以在不创建实体对象的情况下，直接设置更新字段和条件。

  • LambdaQueryWrapper：这是一个基于 Lambda 表达式的查询条件构造器，它通过 Lambda 表达式来引用实体类的属性，从而避免了硬编码字段名。这种方式提高了代码的可读性和可维护性，尤其是在字段名可能发生变化的情况下。

  • LambdaUpdateWrapper：类似于 LambdaQueryWrapper，LambdaUpdateWrapper 是基于 Lambda 表达式的更新条件构造器。它允许你使用 Lambda 表达式来指定更新字段和条件，同样避免了硬编码字段名的问题。

功能详解

MyBatis-Plus 的 Wrapper 类是构建复杂查询和更新条件的关键工具。它允许开发者以链式调用的方式构造 SQL 的 WHERE 子句，提供了极大的灵活性和便利性。

以下是对 Wrapper 功能的提示和注意事项。

提示

条件判断：Wrapper 方法通常接受一个 boolean 类型的参数，用于决定是否将该条件加入到最终的 SQL 中。例如：

queryWrapper.like(StringUtils.isNotBlank(name), Entity::getName, name)
        .eq(age != null && age >= 0, Entity::getAge, age);

默认行为：如果某个方法没有显式提供 boolean 类型的参数，则默认为 true，即条件总是会被加入到 SQL 中。

泛型参数：Wrapper 类是泛型类，其中 Param 通常指的是 Wrapper 的子类实例，如 QueryWrapper、UpdateWrapper 等。

字段引用：在 LambdaWrapper 中，R 代表的是一个函数，用于引用实体类的属性，例如 Entity::getId。而在普通 Wrapper 中，R 代表的是数据库字段名。

字段名注意事项：当 R 具体类型为 String 时，表示的是数据库字段名，而不是实体类数据字段名。如果字段名是数据库关键字，需要使用转义符包裹。

集合参数：如果方法的参数是 Map 或 List，当它们为空时，对应的 SQL 条件不会被加入到最终的 SQL 中。

基本方法

allEq 全等

allEq 方法是 MyBatis-Plus 中用于构建查询条件的方法之一，它允许我们通过一个 Map 来设置多个字段的相等条件。

eq 相等

eq 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的相等条件。

ne 不等

ne 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的不相等条件。

gt 大于

gt 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的大于条件。

ge 大于等于

ge 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的大于等于条件。

lt 小于

ge 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的小于条件。

le 小于等于

ge 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的小于等于条件。

between

between 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的 BETWEEN 条件。

notBetween

notBetween 方法是 MyBatis-Plus 中用于构建查询条件的另一个基本方法，它用于设置单个字段的 NOT BETWEEN 条件。

like

like 方法是 MyBatis-Plus 中用于构建模糊查询条件的基本方法之一，它用于设置单个字段的 LIKE 条件。

notLike

notLike 方法是 MyBatis-Plus 中用于构建模糊查询条件的另一个基本方法，它用于设置单个字段的 NOT LIKE 条件。

likeLeft 右模糊匹配

likeLeft 方法是 MyBatis-Plus 中用于构建模糊查询条件的基本方法之一，它用于设置单个字段的右模糊匹配条件。

notLikeLeft 非右模糊匹配

notLikeLeft 方法是 MyBatis-Plus 中用于构建模糊查询条件的另一个基本方法，它用于设置单个字段的非右模糊匹配条件。

likeRight 左模糊匹配

likeRight 方法是 MyBatis-Plus 中用于构建模糊查询条件的基本方法之一，它用于设置单个字段的左模糊匹配条件。

notLikeRight 非左模糊匹配

notLikeRight 方法是 MyBatis-Plus 中用于构建模糊查询条件的另一个基本方法，它用于设置单个字段的非左模糊匹配条件。

isNull 为空

isNull 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的 IS NULL 条件。

isNotNull 不为空

isNull 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的 IS NOT NULL 条件。

in

in 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的 IN 条件，即字段的值在给定的集合中。

notIn

notIn 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的 NOT IN 条件，即字段的值不在给定的集合中。

or

or 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于在查询条件中添加 OR 逻辑。通过调用 or 方法，可以改变后续查询条件的连接方式，从默认的 AND 连接变为 OR 连接。

and

and 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于在查询条件中添加 AND 逻辑。通过调用 and 方法，可以创建 AND 嵌套条件，即在一个 AND 逻辑块中包含多个查询条件。

高级方法

inSql-使用SQL生成IN子句中的值集合

inSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置单个字段的 IN 条件，但与 in 方法不同的是，inSql 允许你直接使用 SQL 语句来生成 IN 子句中的值集合。

示例

普通 Wrapper (QueryWrapper)：

java
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.inSql("age", "1,2,3,4,5,6");

Lambda Wrapper (LambdaQueryWrapper)：

java
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.inSql(User::getAge, "1,2,3,4,5,6");

生成的 SQL

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age IN (1, 2, 3, 4, 5, 6)

使用子查询的示例：

java
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.inSql("id", "select id from other_table where id < 3");

生成的 SQL

sql
SELECT * FROM user WHERE id IN (select id from other_table where id < 3)

notInSql-使用SQL生成NOT IN子句中的值集合

notInSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置单个字段的 NOT IN 条件，但与 notIn 方法不同的是，notInSql 允许你直接使用 SQL 语句来生成 NOT IN 子句中的值集合。

示例

普通 Wrapper (QueryWrapper)：

java
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notInSql("age", "1,2,3,4,5,6");

Lambda Wrapper (LambdaQueryWrapper)：

java
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notInSql(User::getAge, "1,2,3,4,5,6");

生成的 SQL

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age NOT IN (1, 2, 3, 4, 5, 6)

使用子查询的示例：

java
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.inSql("id", "select id from other_table where id < 3");

生成的 SQL

sql
SELECT * FROM user WHERE id NOT IN (select id from other_table where id < 3)

eqSql(since3.5.6)-字段和sql结果匹配

eqSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，允许你设置一个字段等于（EQ）某个 SQL 语句的结果。这个方法特别适用于需要将字段值与子查询结果进行比较的场景。

示例

java

//普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eqSql("id", "select MAX(id) from table");

//Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eqSql(User::getId, "select MAX(id) from table");

结果

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id = (select MAX(id) from table)

gtSql(since3.4.3.2)字段大于sql结果

gtSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，允许你设置一个字段大于（GT）某个 SQL 语句的结果。

示例

java
//普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gtSql("id", "select id from table where name = 'xx'");

//Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.gtSql(User::getId, "select id from table where name = 'xx'");

结果

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id > (select id from table where name = 'xx')

geSql(since3.4.3.2)字段大于等于sql结果

geSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，允许你设置一个字段大于等于（GE）某个 SQL 语句的结果。

示例

java
//普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.geSql("id", "select id from table where name = 'xx'");

//Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.geSql(User::getId, "select id from table where name = 'xx'");

结果

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id >= (select id from table where name = 'xx')

ltSql(since3.4.3.2)字段小于sql结果

ltSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，允许你设置一个字段小于（LT）某个 SQL 语句的结果。

示例

java
//普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.ltSql("id", "select id from table where name = 'xx'");

//Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.ltSql(User::getId, "select id from table where name = 'xx'");

结果

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id < (select id from table where name = 'xx')

leSql(since3.4.3.2)字段小于等于sql结果

geSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，允许你设置一个字段大于等于（GE）某个 SQL 语句的结果。

示例

java
//普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.leSql("id", "select id from table where name = 'xx'");

//Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.leSql(User::getId, "select id from table where name = 'xx'");

结果

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id <= (select id from table where name = 'xx')

groupBy 分组

groupBy 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询结果的分组条件。通过指定一个或多个字段，groupBy 方法可以生成 SQL 语句中的 GROUP BY 子句。

示例

java
//普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.groupBy("id", "name");

//Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.groupBy(User::getId, User::getName);

结果

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user GROUP BY id, name

orderByAsc

orderByAsc 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询结果的升序排序条件。通过指定一个或多个字段，orderByAsc 方法可以生成 SQL 语句中的 ORDER BY 子句，并指定升序排序。

示例

java
//普通 Wrapper (QueryWrapper)：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByAsc("id", "name");

//Lambda Wrapper (LambdaQueryWrapper)：

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.orderByAsc(User::getId, User::getName);

结果

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user ORDER BY id ASC, name ASC

orderByDesc

orderByDesc 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询结果的降序排序条件。通过指定一个或多个字段，orderByDesc 方法可以生成 SQL 语句中的 ORDER BY 子句，并指定降序排序。

示例

java
// 普通 Wrapper (QueryWrapper)：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("id", "name");

// Lambda Wrapper (LambdaQueryWrapper)：

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.orderByDesc(User::getId, User::getName);

结果

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user ORDER BY id DESC, name DESC

orderBy

java
//普通 Wrapper (QueryWrapper)：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderBy(true, true, "id", "name");

//Lambda Wrapper (LambdaQueryWrapper)：

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.orderBy(true, true, User::getId, User::getName);

结果

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user ORDER BY id ASC, name ASC

having

having 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置 HAVING 子句，通常与 GROUP BY 一起使用，用于对分组后的数据进行条件筛选。

示例

java

//普通 Wrapper (QueryWrapper)：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.groupBy("age").having("sum(age) > 10");

//Lambda Wrapper (LambdaQueryWrapper)：

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.groupBy(User::getAge).having("sum(age) > {0}", 10);

结果

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user GROUP BY age HAVING sum(age) > 10

func 根据条件执行不同查询

func 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它提供了一种在链式调用中根据条件执行不同查询操作的机制。通过传入一个 Consumer 函数式接口，func 方法允许你在不中断链式调用的情况下，根据条件执行不同的查询构建逻辑。

示例

java
//普通 Wrapper (QueryWrapper)：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.func(i -> {
    if (true) {
        i.eq("id", 1);
    } else {
        i.ne("id", 1);
    }
});

//Lambda Wrapper (LambdaQueryWrapper)：

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.func(i -> {
    if (true) {
        i.eq(User::getId, 1);
    } else {
        i.ne(User::getId, 1);
    }
});

生成的 SQL

sql
-- 根据条件生成的 SQL 会有所不同
-- 如果条件为 true，则生成的 SQL 为：
SELECT * FROM user WHERE id = 1

-- 如果条件为 false，则生成的 SQL 为：
SELECT * FROM user WHERE id != 1

nested 创建独立的查询条件块

nested 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于创建一个独立的查询条件块，不带默认的 AND 或 OR 逻辑。通过调用 nested 方法，可以在查询条件中添加一个嵌套的子句，该子句可以包含多个查询条件，并且可以被外部查询条件通过 AND 或 OR 连接。

示例

java
//普通 Wrapper (QueryWrapper)：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.nested(i -> i.eq("name", "李白").ne("status", "活着"));

//Lambda Wrapper (LambdaQueryWrapper)：

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.nested(i -> i.eq(User::getName, "李白").ne(User::getStatus, "活着"));

生成的 SQL

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE (name = '李白' AND status <> '活着')

apply 直接拼接SQL片段到查询语句

apply 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它允许你直接拼接 SQL 片段到查询条件中。这个方法特别适用于需要使用数据库函数或其他复杂 SQL 构造的场景。

示例

java
//普通 Wrapper (QueryWrapper)：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.apply("id = 1");

//Lambda Wrapper (LambdaQueryWrapper)：

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.apply("date_format(dateColumn, '%Y-%m-%d') = '2008-08-08'");

//使用参数占位符的示例：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.apply("date_format(dateColumn, '%Y-%m-%d') = {0}", "2008-08-08");

生成的 SQL

sql
-- 普通 Wrapper 生成的 SQL
SELECT * FROM user WHERE id = 1

-- Lambda Wrapper 生成的 SQL
SELECT * FROM user WHERE date_format(dateColumn, '%Y-%m-%d') = '2008-08-08'

-- 使用参数占位符生成的 SQL
SELECT * FROM user WHERE date_format(dateColumn, '%Y-%m-%d') = '2008-08-08'

last 直接在查询后面添加sql片段

last 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它允许你直接在查询的最后添加一个 SQL 片段，而不受 MyBatis-Plus 的查询优化规则影响。这个方法应该谨慎使用，因为它可能会绕过 MyBatis-Plus 的查询优化。

示例

java
//普通 Wrapper (QueryWrapper)：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.last("limit 1");

//Lambda Wrapper (LambdaQueryWrapper)：

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.last("limit 1");

生成的 SQL

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user LIMIT 1

exists

exists 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于在查询中添加一个 EXISTS 子查询。通过调用 exists 方法，可以将一个完整的 SQL 子查询作为 EXISTS 条件添加到主查询中。

示例

java
//普通 Wrapper (QueryWrapper)：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.exists("select id from table where age = 1");

//Lambda Wrapper (LambdaQueryWrapper)：

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.exists("select id from table where age = 1");

生成的 SQL

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE EXISTS (select id from table where age = 1)

notExists

notExists 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于在查询中添加一个 NOT EXISTS 子查询。通过调用 notExists 方法，可以将一个完整的 SQL 子查询作为 NOT EXISTS 条件添加到主查询中。

示例

java
//普通 Wrapper (QueryWrapper)：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notExists("select id from table where age = 1");

//Lambda Wrapper (LambdaQueryWrapper)：

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notExists("select id from table where age = 1");

生成的 SQL

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE NOT EXISTS (select id from table where age = 1)

select 设置查询的字段

select 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询的字段。通过调用 select 方法，可以指定在查询结果中包含哪些字段，从而实现字段级别的查询定制。

示例

java
//普通 Wrapper (QueryWrapper)：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("id", "name", "age");

//Lambda Wrapper (LambdaQueryWrapper)：

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.select(User::getId, User::getName, User::getAge);

//使用 Predicate 过滤字段的示例：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select(i -> i.getProperty().startsWith("test"));

生成的 SQL

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT id, name, age FROM user

-- 使用 Predicate 过滤字段生成的 SQL
SELECT testField1, testField2 FROM user

set

set 方法是 MyBatis-Plus 中用于构建更新操作的高级方法之一，它用于设置更新语句中的 SET 字段。通过调用 set 方法，可以指定在更新操作中要修改的字段及其新值。

示例

java
//普通 Wrapper (UpdateWrapper)：

UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.set("name", "老李头");

//Lambda Wrapper (LambdaUpdateWrapper)：

LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.set(User::getName, "老李头");

生成的 SQL

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
UPDATE user SET name = '老李头'

使用条件控制的示例：

java
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.set(true, "name", "");

生成的 SQL

sql
-- 使用条件控制的 SQL
UPDATE user SET name = ''

setSql 将sql作为set子句添加更新

setSql 方法是 MyBatis-Plus 中用于构建更新操作的高级方法之一，它允许你直接设置更新语句中的 SET 部分 SQL。通过调用 setSql 方法，可以将一个自定义的 SQL 片段作为 SET 子句添加到更新语句中。

示例

java
setSql("name = '老李头'")
setSql("dateColumn={0}", LocalDate.now())
setSql("type={0,javaType=int,jdbcType=NUMERIC,typeHandler=xxx.xxx.MyTypeHandler}", "待处理字符串");

setIncrBy（Since 3.5.6）递增指定的字段的值

setIncrBy 方法是 MyBatis-Plus 中用于更新操作的高级方法之一，它允许你指定一个字段，并使其在数据库中的值增加指定的数值。这个方法特别适用于需要对数值字段进行增量操作的场景。

示例

java
//普通 Wrapper (UpdateWrapper)：

UpdateWrapper<Product> updateWrapper = new UpdateWrapper<>();
updateWrapper.setIncrBy(Product::getNum, 1);

//Lambda Wrapper (LambdaUpdateWrapper)：

LambdaUpdateWrapper<Product> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.setIncrBy(Product::getNum, 1);

生成的 SQL

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
UPDATE product SET num = num + 1

setDecrBy（Since 3.5.6）递减指定的字段的值

setDecrBy 方法是 MyBatis-Plus 中用于更新操作的高级方法之一，它允许你指定一个字段，并使其在数据库中的值减少指定的数值。这个方法特别适用于需要对数值字段进行减量操作的场景。

示例

java
//普通 Wrapper (UpdateWrapper)：

UpdateWrapper<Product> updateWrapper = new UpdateWrapper<>();
updateWrapper.setDecrBy("num", 1);

//Lambda Wrapper (LambdaUpdateWrapper)：

LambdaUpdateWrapper<Product> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.setDecrBy(Product::getNum, 1);

生成的 SQL

sql
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
UPDATE product SET num = num - 1

lambda

lambda 方法是一个便捷的方法，它允许你从 QueryWrapper 或 UpdateWrapper 对象中获取对应的 LambdaQueryWrapper 或 LambdaUpdateWrapper 对象。这样，你就可以使用 Lambda 表达式来构建查询或更新条件，使得代码更加简洁和类型安全。

示例

java
//从 QueryWrapper 获取 LambdaQueryWrapper：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
LambdaQueryWrapper<User> lambdaQueryWrapper = queryWrapper.lambda();
// 使用 Lambda 表达式构建查询条件
lambdaQueryWrapper.eq("name", "张三");

//从 UpdateWrapper 获取 LambdaUpdateWrapper：

UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
LambdaUpdateWrapper<User> lambdaUpdateWrapper = updateWrapper.lambda();
// 使用 Lambda 表达式构建更新条件
lambdaUpdateWrapper.set(User::getName, "李四");

本文作者:Weee

本文链接:

版权声明:本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！