文章目录
- 前言
- 一、功能详解
- 1. allEq
- 2. eq
- 3. ne
- 4. gt
- 5. ge
- 6. lt
- 7. le
- 8. between
- 9. notBetween
- 10. like
- 11. notLike
- 12. likeLeft
- 13. likeRight
- 14. notLikeLeft
- 15. notLikeRight
- 16. isNull
- 17. in
- 18. notIn
- 19. inSql
- 20. notInSql
- 21. eqSqlSince 3.5.6
- 22. gtSql Since 3.4.3.2
- 23. geSql Since 3.4.3.2
- 24. ltSql Since 3.4.3.2
- 25. leSql Since 3.4.3.2
- 26. groupBy
- 27. orderByAsc
- 28. orderByDesc
- 29. orderBy
- 30. having
- 31. func
- 32. or
- 33. and
- 34. nested
- 35. apply
- 36. last
- 37. exists
- 38. notExists
- 39. select
- 40. set
- 41. setSql
- 42. setIncrBy Since 3.5.6
- 43. setDecrBy
- 44. 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 功能的提示和注意事项。
1. allEq
allEq 方法是 MyBatis-Plus 中用于构建查询条件的方法之一，它允许我们通过一个 Map 来设置多个字段的相等条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置所有字段的相等条件，如果字段值为null，则根据null2IsNull参数决定是否设置为IS NULL
allEq(Map<String, Object> params)
allEq(Map<String, Object> params, boolean null2IsNull)
allEq(boolean condition, Map<String, Object> params, boolean null2IsNull)
// 设置所有字段的相等条件，通过filter过滤器决定哪些字段应该被包含，如果字段值为null，则根据null2IsNull参数决定是否设置为IS NULL
allEq(BiPredicate<String, Object> filter, Map<String, Object> params)
allEq(BiPredicate<String, Object> filter, Map<String, Object> params, boolean null2IsNull)
allEq(boolean condition, BiPredicate<String, Object> filter, Map<String, Object> params, boolean null2IsNull)
参数说明
params：一个Map，其中 key 是数据库字段名，value是对应的字段值。null2IsNull：如果设置为true，当Map中的value为null时，会调用isNull方法；如果设置为false，则会忽略value为null的键值对。filter：一个BiPredicate，用于过滤哪些字段应该被包含在查询条件中。condition：一个布尔值，用于控制是否应用这些条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.allEq(Map.of("id", 1, "name", "老王")).eq("age", null);
at java.base/java.util.Objects.requireNonNull(Objects.java:208)
at java.base/java.util.ImmutableCollections$MapN.(ImmutableCollections.java:1186)
at java.base/java.util.Map.of(Map.java:1395)
jdk17中Map.of不能传递null值,这里我们把null值参数拆到了后面使用eq处理,以达到同等效果
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.allEq(Map.of(User::getId, 1, User::getName, "老王")).eq(User::getAge, null);
带过滤器的普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper1 = new QueryWrapper<>();
queryWrapper1.allEq((field, value) -> field.contains("a"), Map.of("id", 1, "name", "老王")).eq( "age", null);
带过滤器的 Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.allEq((field, value) -> {
LambdaMeta meta = LambdaUtils.extract(field);
String fieldName = PropertyNamer.methodToProperty(meta.getImplMethodName());
System.out.println(fieldName+","+value);
return fieldName.contains("a");
},Map.of(User::getId, 1, User::getName, "老王")).eq(User::getAge, null);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id = 1 AND name = '老王' AND age IS NULL
-- 带过滤器的普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name = '老王' AND age IS NULL
2. eq
eq 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的相等条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的相等条件
eq(R column, Object val)
// 根据条件设置指定字段的相等条件
eq(boolean condition, R column, Object val)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。val：与字段名对应的值。condition：一个布尔值，用于控制是否应用这个相等条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "老王");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(User::getName, "老王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name = '老王'
3. ne
ne 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的不相等条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的不相等条件
ne(R column, Object val)
// 根据条件设置指定字段的不相等条件
ne(boolean condition, R column, Object val)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。val：与字段名对应的值。condition：一个布尔值，用于控制是否应用这个不相等条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.ne("name", "老王");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.ne(User::getName, "老王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name <> '老王'
4. gt
gt 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的大于条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的大于条件
gt(R column, Object val)
// 根据条件设置指定字段的大于条件
gt(boolean condition, R column, Object val)
参数说明
column：数据库字段名或使用 Lambda 表达式的字段名。val：与字段名对应的值。condition：一个布尔值，用于控制是否应用这个大于条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 18);
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.gt(User::getAge, 18);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age > 18
注意事项
gt方法适用于数值型字段，对于字符串等非数值型字段，使用gt可能会导致不期望的结果或错误。- 在使用
gt方法时，确保val参数的类型与字段类型相匹配，以避免类型转换错误。- 如果需要根据某些条件动态添加大于条件，可以使用带有
condition参数的重载方法。
5. ge
ge 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的大于等于条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的大于等于条件
ge(R column, Object val)
// 根据条件设置指定字段的大于等于条件
ge(boolean condition, R column, Object val)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。val：与字段名对应的值。condition：一个布尔值，用于控制是否应用这个大于等于条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.ge("age", 18);
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.ge(User::getAge, 18);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age >= 18
注意事项
ge方法适用于数值型字段，对于字符串等非数值型字段，使用ge可能会导致不期望的结果或错误。- 在使用
ge方法时，确保val参数的类型与字段类型相匹配，以避免类型转换错误。- 如果需要根据某些条件动态添加大于等于条件，可以使用带有
condition参数的重载方法。
6. lt
lt 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的小于条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的小于条件
lt(R column, Object val)
// 根据条件设置指定字段的小于条件
lt(boolean condition, R column, Object val)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。val：与字段名对应的值。condition：一个布尔值，用于控制是否应用这个小于条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.lt("age", 18);
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.lt(User::getAge, 18);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age < 18
注意事项
lt方法适用于数值型字段，对于字符串等非数值型字段，使用lt可能会导致不期望的结果或错误。- 在使用
lt方法时，确保val参数的类型与字段类型相匹配，以避免类型转换错误。- 如果需要根据某些条件动态添加小于条件，可以使用带有
condition参数的重载方法。
7. le
le 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的小于等于条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的小于等于条件
le(R column, Object val)
// 根据条件设置指定字段的小于等于条件
le(boolean condition, R column, Object val)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。val：与字段名对应的值。condition：一个布尔值，用于控制是否应用这个小于等于条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.le("age", 18);
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.le(User::getAge, 18);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age <= 18
注意事项
le方法适用于数值型字段，对于字符串等非数值型字段，使用le可能会导致不期望的结果或错误。- 在使用
le方法时，确保val参数的类型与字段类型相匹配，以避免类型转换错误。- 如果需要根据某些条件动态添加小于等于条件，可以使用带有
condition参数的重载方法。
8. between
between 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的 BETWEEN 条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 BETWEEN 条件
between(R column, Object val1, Object val2)
// 根据条件设置指定字段的 BETWEEN 条件
between(boolean condition, R column, Object val1, Object val2)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。val1：与字段名对应的第一个值，表示 BETWEEN 条件的起始值。val2：与字段名对应的第二个值，表示 BETWEEN 条件的结束值。condition：一个布尔值，用于控制是否应用这个 BETWEEN 条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.between("age", 18, 30);
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.between(User::getAge, 18, 30);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age BETWEEN 18 AND 30
注意事项
between方法适用于数值型字段，对于字符串等非数值型字段，使用between可能会导致不期望的结果或错误。- 在使用
between方法时，确保val1和val2参数的类型与字段类型相匹配，以避免类型转换错误。- 如果需要根据某些条件动态添加 BETWEEN 条件，可以使用带有
condition参数的重载方法。
9. notBetween
notBetween 方法是 MyBatis-Plus 中用于构建查询条件的另一个基本方法，它用于设置单个字段的 NOT BETWEEN 条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 NOT BETWEEN 条件
notBetween(R column, Object val1, Object val2)
// 根据条件设置指定字段的 NOT BETWEEN 条件
notBetween(boolean condition, R column, Object val1, Object val2)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。val1：与字段名对应的第一个值，表示 NOT BETWEEN 条件的起始值。val2：与字段名对应的第二个值，表示 NOT BETWEEN 条件的结束值。condition：一个布尔值，用于控制是否应用这个 NOT BETWEEN 条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notBetween("age", 18, 30);
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notBetween(User::getAge, 18, 30);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age NOT BETWEEN 18 AND 30
注意事项
notBetween方法同样适用于数值型字段，对于字符串等非数值型字段，使用notBetween可能会导致不期望的结果或错误。- 在使用
notBetween方法时，确保val1和val2参数的类型与字段类型相匹配，以避免类型转换错误。- 如果需要根据某些条件动态添加 NOT BETWEEN 条件，可以使用带有
condition参数的重载方法。
10. like
like 方法是 MyBatis-Plus 中用于构建模糊查询条件的基本方法之一，它用于设置单个字段的 LIKE 条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 LIKE 条件
like(R column, Object val)
// 根据条件设置指定字段的 LIKE 条件
like(boolean condition, R column, Object val)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。val：与字段名对应的值，表示 LIKE 条件中的搜索值。condition：一个布尔值，用于控制是否应用这个 LIKE 条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like("name", "王");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(User::getName, "王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name LIKE '%王%'
注意事项
like方法适用于字符串类型的字段，用于模糊匹配。- 默认情况下，
like方法会在搜索值前后添加%，实现全模糊匹配。如果需要左模糊或右模糊匹配，可以使用likeLeft或likeRight方法。- 在使用
like方法时，确保val参数的类型是字符串，以避免类型转换错误。- 如果需要根据某些条件动态添加 LIKE 条件，可以使用带有
condition参数的重载方法。
11. notLike
notLike 方法是 MyBatis-Plus 中用于构建模糊查询条件的另一个基本方法，它用于设置单个字段的 NOT LIKE 条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 NOT LIKE 条件
notLike(R column, Object val)
// 根据条件设置指定字段的 NOT LIKE 条件
notLike(boolean condition, R column, Object val)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。val：与字段名对应的值，表示 NOT LIKE 条件中的搜索值。condition：一个布尔值，用于控制是否应用这个 NOT LIKE 条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notLike("name", "王");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notLike(User::getName, "王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name NOT LIKE '%王%'
注意事项
notLike方法适用于字符串类型的字段，用于排除特定的模糊匹配。- 默认情况下，
notLike方法会在搜索值前后添加%，实现全模糊排除。如果需要排除左模糊或排除右模糊匹配，可以使用notLikeLeft或notLikeRight方法。- 在使用
notLike方法时，确保val参数的类型是字符串，以避免类型转换错误。- 如果需要根据某些条件动态添加 NOT LIKE 条件，可以使用带有
condition参数的重载方法。
12. likeLeft
likeLeft 方法是 MyBatis-Plus 中用于构建模糊查询条件的基本方法之一，它用于设置单个字段的左模糊匹配条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的左模糊匹配条件
likeLeft(R column, Object val)
// 根据条件设置指定字段的左模糊匹配条件
likeLeft(boolean condition, R column, Object val)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。val：与字段名对应的值，表示左模糊匹配条件中的搜索值。condition：一个布尔值，用于控制是否应用这个左模糊匹配条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.likeLeft("name", "王");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.likeLeft(User::getName, "王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name LIKE '%王'
注意事项
likeLeft方法适用于字符串类型的字段，用于左模糊匹配，即匹配以指定字符串开头的记录。- 默认情况下，
likeLeft方法会在搜索值前添加%，实现左模糊匹配。如果需要全模糊或右模糊匹配，可以使用like或likeRight方法。- 在使用
likeLeft方法时，确保val参数的类型是字符串，以避免类型转换错误。- 如果需要根据某些条件动态添加左模糊匹配条件，可以使用带有
condition参数的重载方法。
通过上述优化，likeLeft 方法的文档更加清晰地展示了其用法、参数说明、示例以及注意事项，使得开发者能够更容易理解和正确使用该方法。
13. likeRight
likeRight 方法是 MyBatis-Plus 中用于构建模糊查询条件的基本方法之一，它用于设置单个字段的右模糊匹配条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的右模糊匹配条件
likeRight(R column, Object val)
// 根据条件设置指定字段的右模糊匹配条件
likeRight(boolean condition, R column, Object val)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。val：与字段名对应的值，表示右模糊匹配条件中的搜索值。condition：一个布尔值，用于控制是否应用这个右模糊匹配条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.likeRight("name", "王");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.likeRight(User::getName, "王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name LIKE '王%'
注意事项
likeRight方法适用于字符串类型的字段，用于右模糊匹配，即匹配以指定字符串结尾的记录。- 默认情况下，
likeRight方法会在搜索值后添加%，实现右模糊匹配。如果需要全模糊或左模糊匹配，可以使用like或likeLeft方法。- 在使用
likeRight方法时，确保val参数的类型是字符串，以避免类型转换错误。- 如果需要根据某些条件动态添加右模糊匹配条件，可以使用带有
condition参数的重载方法。
14. notLikeLeft
notLikeLeft 方法是 MyBatis-Plus 中用于构建模糊查询条件的另一个基本方法，它用于设置单个字段的非左模糊匹配条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的非左模糊匹配条件
notLikeLeft(R column, Object val)
// 根据条件设置指定字段的非左模糊匹配条件
notLikeLeft(boolean condition, R column, Object val)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。val：与字段名对应的值，表示非左模糊匹配条件中的搜索值。condition：一个布尔值，用于控制是否应用这个非左模糊匹配条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notLikeLeft("name", "王");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notLikeLeft(User::getName, "王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name NOT LIKE '%王'
注意事项
notLikeLeft方法适用于字符串类型的字段，用于排除以指定字符串开头的记录。- 默认情况下，
notLikeLeft方法会在搜索值前添加%，实现非左模糊匹配。如果需要排除全模糊或右模糊匹配，可以使用notLike或notLikeRight方法。- 在使用
notLikeLeft方法时，确保val参数的类型是字符串，以避免类型转换错误。- 如果需要根据某些条件动态添加非左模糊匹配条件，可以使用带有
condition参数的重载方法。
15. notLikeRight
notLikeRight 方法是 MyBatis-Plus 中用于构建模糊查询条件的另一个基本方法，它用于设置单个字段的非右模糊匹配条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的非右模糊匹配条件
notLikeRight(R column, Object val)
// 根据条件设置指定字段的非右模糊匹配条件
notLikeRight(boolean condition, R column, Object val)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。val：与字段名对应的值，表示非右模糊匹配条件中的搜索值。condition：一个布尔值，用于控制是否应用这个非右模糊匹配条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notLikeRight("name", "王");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notLikeRight(User::getName, "王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name NOT LIKE '王%'
注意事项
notLikeRight方法适用于字符串类型的字段，用于排除以指定字符串结尾的记录。- 默认情况下，
notLikeRight方法会在搜索值后添加%，实现非右模糊匹配。如果需要排除全模糊或左模糊匹配，可以使用notLike或notLikeLeft方法。- 在使用
notLikeRight方法时，确保val参数的类型是字符串，以避免类型转换错误。- 如果需要根据某些条件动态添加非右模糊匹配条件，可以使用带有
condition参数的重载方法。
通过上述优化，notLikeRight 方法的文档更加清晰地展示了其用法、参数说明、示例以及注意事项，使得开发者能够更容易理解和正确使用该方法。
16. isNull
isNull方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的 IS NULL 条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 IS NULL 条件
isNull(R column)
// 根据条件设置指定字段的 IS NULL 条件
isNull(boolean condition, R column)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。condition：一个布尔值，用于控制是否应用这个 IS NULL 条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.isNull("name");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.isNull(User::getName);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name IS NULL
注意事项
isNull方法适用于所有类型的字段，用于查询字段值为 NULL 的记录。- 在使用
isNull方法时，确保column参数正确指向了数据库中的字段名或使用Lambda表达式的字段名。- 如果需要根据某些条件动态添加 IS NULL 条件，可以使用带有
condition参数的重载方法。
17. in
in 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的 IN 条件，即字段的值在给定的集合中。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 IN 条件，使用集合、
in(R column, Collection<?> value)
in(boolean condition, R column, Collection<?> value)
// 设置指定字段的 IN 条件，使用可变参数
in(R column, Object... values)
in(boolean condition, R column, Object... values)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。value：一个集合，包含 IN 条件中字段可能的值。values：一个可变参数列表，包含 IN 条件中字段可能的值。condition：一个布尔值，用于控制是否应用这个 IN 条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.in("age", Arrays.asList(1, 2, 3));
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.in(User::getAge, Arrays.asList(1, 2, 3));
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age IN (1, 2, 3)
注意事项
in方法适用于所有类型的字段，用于查询字段值在给定集合中的记录。- 在使用
in方法时，确保column参数正确指向了数据库中的字段名或使用Lambda表达式的字段名。- 如果需要根据某些条件动态添加 IN 条件，可以使用带有
condition参数的重载方法。
18. notIn
notIn 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的 NOT IN 条件，即字段的值不在给定的集合中。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 NOT IN 条件，使用集合
notIn(R column, Collection<?> value)
notIn(boolean condition, R column, Collection<?> value)
// 设置指定字段的 NOT IN 条件，使用可变参数
notIn(R column, Object... values)
notIn(boolean condition, R column, Object... values)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。value：一个集合，包含 NOT IN 条件中字段可能的值。values：一个可变参数列表，包含 NOT IN 条件中字段可能的值。condition：一个布尔值，用于控制是否应用这个 NOT IN 条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notIn("age", Arrays.asList(1, 2, 3));
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notIn(User::getAge, Arrays.asList(1, 2, 3));
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age NOT IN (1, 2, 3)
注意事项
notIn方法适用于所有类型的字段，用于查询字段值不在给定集合中的记录。- 在使用
notIn方法时，确保column参数正确指向了数据库中的字段名或使用Lambda表达式的字段名。- 如果需要根据某些条件动态添加 NOT IN 条件，可以使用带有
condition参数的重载方法。
19. inSql
inSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置单个字段的 IN 条件，但与 in 方法不同的是，inSql 允许你直接使用 SQL 语句来生成 IN 子句中的值集合。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 IN 条件，使用 SQL 语句
inSql(R column, String sqlValue)
inSql(boolean condition, R column, String sqlValue)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。sqlValue：一个字符串，包含用于生成 IN 子句中值集合的 SQL 语句。condition：一个布尔值，用于控制是否应用这个 IN 条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.inSql("age", "1,2,3,4,5,6");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.inSql(User::getAge, "1,2,3,4,5,6");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age IN (1, 2, 3, 4, 5, 6)
使用子查询的示例：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.inSql("id", "select id from other_table where id < 3");
生成的 SQL
SELECT * FROM user WHERE id IN (select id from other_table where id < 3)
注意事项
inSql方法允许你使用 SQL 语句来生成 IN 子句中的值集合，这为复杂的查询条件提供了灵活性。- 在使用
inSql方法时，确保column参数正确指向了数据库中的字段名或使用Lambda表达式的字段名。sqlValue参数应该是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。- 如果需要根据某些条件动态添加 IN 条件，可以使用带有
condition参数的重载方法。
20. notInSql
notInSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置单个字段的 NOT IN 条件，但与 notIn 方法不同的是，notInSql 允许你直接使用 SQL 语句来生成 NOT IN 子句中的值集合。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 NOT IN 条件，使用 SQL 语句
notInSql(R column, String sqlValue)
notInSql(boolean condition, R column, String sqlValue)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。sqlValue：一个字符串，包含用于生成 NOT IN 子句中值集合的 SQL 语句。condition：一个布尔值，用于控制是否应用这个 NOT IN 条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notInSql("age", "1,2,3,4,5,6");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notInSql(User::getAge, "1,2,3,4,5,6");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age NOT IN (1, 2, 3, 4, 5, 6)
使用子查询的示例：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notInSql("id", "select id from other_table where id < 3");
生成的 SQL
SELECT * FROM user WHERE id NOT IN (select id from user where id < 3)
注意事项
notInSql方法允许你使用 SQL 语句来生成 NOT IN 子句中的值集合，这为复杂的查询条件提供了灵活性。- 在使用
notInSql方法时，确保column参数正确指向了数据库中的字段名或使用Lambda表达式的字段名。sqlValue参数应该是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。- 如果需要根据某些条件动态添加 NOT IN 条件，可以使用带有
condition参数的重载方法。
21. eqSqlSince 3.5.6
eqSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，允许你设置一个字段等于（EQ）某个 SQL 语句的结果。这个方法特别适用于需要将字段值与子查询结果进行比较的场景。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段等于 SQL 语句的结果
eqSql(R column, String inValue)
// 在条件满足时设置指定字段等于 SQL 语句的结果
eqSql(boolean condition, R column, String inValue)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。inValue：一个字符串，包含用于生成等于条件的 SQL 语句。condition：一个布尔值，用于控制是否应用这个等于条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eqSql("id", "select MAX(id) from user");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eqSql(User::getId, "select MAX(id) from user");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id = (select MAX(id) from user)
注意事项
eqSql方法允许你将字段值与 SQL 语句的结果进行比较，这为复杂的查询条件提供了灵活性。- 在使用
eqSql方法时，确保column参数正确指向了数据库中的字段名或使用Lambda表达式的字段名。inValue参数应该是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。- 如果需要根据某些条件动态添加等于条件，可以使用带有
condition参数的重载方法。
22. gtSql Since 3.4.3.2
gtSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，允许你设置一个字段大于（GT）某个 SQL 语句的结果。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段大于 SQL 语句的结果
gtSql(R column, String inValue)
// 在条件满足时设置指定字段大于 SQL 语句的结果
gtSql(boolean condition, R column, String inValue)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。inValue：一个字符串，包含用于生成大于条件的 SQL 语句。condition：一个布尔值，用于控制是否应用这个大于条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gtSql("id", "select id from user where name = 'xx'");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.gtSql(User::getId, "select id from user where name = 'xx'");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id > (select id from user where name = 'xx')
注意事项
gtSql方法允许你将字段值与 SQL 语句的结果进行比较，这为复杂的查询条件提供了灵活性。- 在使用
gtSql方法时，确保column参数正确指向了数据库中的字段名或使用Lambda表达式的字段名。inValue参数应该是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。- 如果需要根据某些条件动态添加大于条件，可以使用带有
condition参数的重载方法。
23. geSql Since 3.4.3.2
geSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，允许你设置一个字段大于等于（GE）某个 SQL 语句的结果。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段大于等于 SQL 语句的结果
geSql(R column, String inValue)
// 在条件满足时设置指定字段大于等于 SQL 语句的结果
geSql(boolean condition, R column, String inValue)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。inValue：一个字符串，包含用于生成大于等于条件的 SQL 语句。condition：一个布尔值，用于控制是否应用这个大于等于条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.geSql("id", "select id from user where name = 'xx'");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.geSql(User::getId, "select id from user where name = 'xx'");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id >= (select id from user where name = 'xx')
注意事项
geSql方法允许你将字段值与 SQL 语句的结果进行比较，这为复杂的查询条件提供了灵活性。- 在使用
geSql方法时，确保column参数正确指向了数据库中的字段名或使用Lambda表达式的字段名。inValue参数应该是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。- 如果需要根据某些条件动态添加大于等于条件，可以使用带有
condition参数的重载方法。
24. ltSql Since 3.4.3.2
ltSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，允许你设置一个字段小于（LT）某个 SQL 语句的结果。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段小于 SQL 语句的结果
ltSql(R column, String inValue)
// 在条件满足时设置指定字段小于 SQL 语句的结果
ltSql(boolean condition, R column, String inValue)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。inValue：一个字符串，包含用于生成小于条件的 SQL 语句。condition：一个布尔值，用于控制是否应用这个小于条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.ltSql("id", "select id from user where name = 'xx'");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.ltSql(User::getId, "select id from user where name = 'xx'");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id < (select id from user where name = 'xx')
注意事项
ltSql方法允许你将字段值与 SQL 语句的结果进行比较，这为复杂的查询条件提供了灵活性。- 在使用
ltSql方法时，确保column参数正确指向了数据库中的字段名或使用Lambda表达式的字段名。inValue参数应该是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态入并直接引用。- 如果需要根据某些条件动态添加小于条件，可以使用带有
condition参数的重载方法。
25. leSql Since 3.4.3.2
leSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，允许你设置一个字段小于等于（LE）某个 SQL 语句的结果。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段小于等于 SQL 语句的结果
leSql(R column, String inValue)
// 在条件满足时设置指定字段小于等于 SQL 语句的结果
leSql(boolean condition, R column, String inValue)
参数说明
column：数据库字段名或使用Lambda表达式的字段名。inValue：一个字符串，包含用于生成小于等于条件的 SQL 语句。condition：一个布尔值，用于控制是否应用这个小于等于条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.leSql("id", "select id from user where name = 'xx'");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.leSql(User::getId, "select id from user where name = 'xx'");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id <= (select id from user where name = 'xx')
注意事项
leSql方法允许你将字段值与 SQL 语句的结果进行比较，这为复杂的查询条件提供了灵活性。- 在使用
leSql方法时，确保column参数正确指向了数据库中的字段名或使用Lambda表达式的字段名。inValue参数应该是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。- 如果需要根据某些条件动态添加小于等于条件，可以使用带有
condition参数的重载方法。
26. groupBy
groupBy 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询结果的分组条件。通过指定一个或多个字段，groupBy 方法可以生成 SQL 语句中的 GROUP BY 子句。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置分组条件，使用字段名
groupBy(R... columns)
groupBy(boolean condition, R... columns)
参数说明
columns：一个可变参数列表，包含用于分组的字段名。condition：一个布尔值，用于控制是否应用这个分组条件。
示例
普通 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
注意事项
groupBy方法适用于需要对查询结果进行分组的场景。- 在使用
groupBy方法时，确保columns参数正确指向了数据库中的字段名或使用Lambda表达式的字段名。- 如果需要根据某些条件动态添加分组条件，可以使用带有
condition参数的重载方法。
27. orderByAsc
orderByAsc方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询结果的升序排序条件。通过指定一个或多个字段，orderByAsc 方法可以生成 SQL 语句中的 ORDER BY 子句，并指定升序排序。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置升序排序条件，使用字段名
orderByAsc(R... columns)
orderByAsc(boolean condition, R... columns)
参数说明
columns：一个可变参数列表，包含用于排序的字段名。condition：一个布尔值，用于控制是否应用这个排序条件。
示例
普通 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
注意事项
orderByAsc方法适用于需要对查询结果进行升序排序的场景。- 在使用
orderByAsc方法时，确保columns参数正确指向了数据库中的字段名或使用Lambda表达式的字段名。- 如果需要根据某些条件动态添加排序条件，可以使用带有
condition参数的重载方法。
28. orderByDesc
orderByDesc 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询结果的降序排序条件。通过指定一个或多个字段，orderByDesc 方法可以生成 SQL 语句中的 ORDER BY 子句，并指定降序排序。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置降序排序条件，使用字段名
orderByDesc(R... columns)
orderByDesc(boolean condition, R... columns)
参数说明
columns：一个可变参数列表，包含用于排序的字段名。condition：一个布尔值，用于控制是否应用这个排序条件。
示例
普通 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
注意事项
orderByDesc方法适用于需要对查询结果进行降序排序的场景。- 在使用
orderByDesc方法时，确保columns参数正确指向了数据库中的字段名或使用Lambda表达式的字段名。- 如果需要根据某些条件动态添加排序条件，可以使用带有
condition参数的重载方法。
29. orderBy
orderBy 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询结果的排序条件。通过指定一个或多个字段以及排序方向（升序或降序），orderBy 方法可以生成 SQL 语句中的 ORDER BY 子句。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置排序条件，使用字段名和排序方向
orderBy(boolean condition, boolean isAsc, R... columns)
参数说明
condition：一个布尔值，用于控制是否应用这个排序条件。isAsc：一个布尔值，表示排序方向。true 表示升序（ASC），false 表示降序（DESC）。columns：一个可变参数列表，包含用于排序的字段名。
示例
普通 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
注意事项
orderBy方法提供了更灵活的排序设置，允许开发者指定排序方向。- 在使用
orderBy方法时，确保columns参数正确指向了数据库中的字段名或使用Lambda表达式的字段名。- 如果需要根据某些条件动态添加排序条件，可以使用带有
condition参数的重载方法。- 排序可以应用于查询结果的展示，也可以用于优化查询性能，例如通过排序来减少需要扫描的数据量。
30. having
having 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置 HAVING 子句，通常与 GROUP BY 一起使用，用于对分组后的数据进行条件筛选。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置 HAVING 子句，使用 SQL 语句和参数
having(String sqlHaving, Object... params)
having(boolean condition, String sqlHaving, Object... params)
参数说明
sqlHaving：一个字符串，包含用于生成 HAVING 子句的 SQL 语句。params：一个可变参数列表，包含 SQL 语句中占位符的替换值。condition：一个布尔值，用于控制是否应用这个 HAVING 条件。
示例
普通 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
注意事项
having方法通常与groupBy方法一起使用，用于对分组后的数据进行进一步的筛选。- 在使用
having方法时，确保sqlHaving参数是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。params参数用于替换sqlHaving中的占位符，确保提供的参数类型和数量与占位符匹配。- 如果需要根据某些条件动态添加 HAVING 条件，可以使用带有
condition参数的重载方法。
31. func
func 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它提供了一种在链式调用中根据条件执行不同查询操作的机制。通过传入一个 Consumer 函数式接口，func 方法允许你在不中断链式调用的情况下，根据条件执行不同的查询构建逻辑。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 根据条件执行不同的查询构建逻辑
func(Consumer<Children> consumer)
func(boolean condition, Consumer<Children> consumer)
参数说明
consumer：一个Consumer函数式接口，它接受一个Children类型的参数，并可以调用Children对象上的方法来构建查询条件。condition：一个布尔值，用于控制是否应用这个Consumer逻辑。
示例
普通 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 会有所不同
-- 如果条件为 true，则生成的 SQL 为：
SELECT * FROM user WHERE id = 1
-- 如果条件为 false，则生成的 SQL 为：
SELECT * FROM user WHERE id != 1
注意事项
func方法提供了一种灵活的方式来根据条件动态构建查询条件，而不需要中断链式调用。- 在使用
func方法时，确保Consumer函数式接口中的逻辑正确构建了所需的查询条件。condition参数用于控制是否应用Consumer逻辑，这允许你根据某些条件动态添加查询条件。- 由于
func方法允许执行复杂的逻辑，因此在使用时需要特别注意代码的可读性和维护性。
32. or
or 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于在查询条件中添加 OR 逻辑。通过调用 or 方法，可以改变后续查询条件的连接方式，从默认的 AND 连接变为 OR 连接。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 改变后续查询条件的连接方式为 OR
or()
or(boolean condition)
// 添加 OR 嵌套条件
or(Consumer<Param> consumer)
or(boolean condition, Consumer<Param> consumer)
参数说明
condition：一个布尔值，用于控制是否应用这个 OR 逻辑。consumer：一个Consumer函数式接口，它接受一个Param类型的参数，并可以调用Param对象上的方法来构建 OR 嵌套条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("id", 1).or().eq("name", "老王");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(User::getId, 1).or().eq(User::getName, "老王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id = 1 OR name = '老王'
OR 嵌套示例：
// 普通 Wrapper
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.or(i -> i.and(j -> j.eq("name", "李白").eq("status", "alive"))
.or(j -> j.eq("name", "杜甫").eq("status", "alive")));
// Lambda Wrapper
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.or(i -> i.and(j -> j.eq(User::getName, "李白").eq(User::getStatus, "alive"))
.or(j -> j.eq(User::getName, "杜甫").eq(User::getStatus, "alive")));
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE (name = '李白' AND status = 'alive') OR (name = '杜甫' AND status = 'alive')
注意事项
- 主动调用
or方法表示紧接着下一个查询条件方法不是用and连接，而是用or连接。- 如果不调用
or方法，则默认使用and连接查询条件。or方法可以嵌套使用，通过传入Consumer函数式接口来构建复杂的 OR 嵌套条件。- 在使用
or方法时，确保condition参数正确控制了 OR 逻辑的应用。or方法的嵌套使用可以构建复杂的查询逻辑，但需要注意代码的可读性和维护性。
33. and
and 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于在查询条件中添加 AND 逻辑。通过调用 and 方法，可以创建 AND 嵌套条件，即在一个 AND 逻辑块中包含多个查询条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 添加 AND 嵌套条件
and(Consumer<Param> consumer)
and(boolean condition, Consumer<Param> consumer)
参数说明
consumer：一个Consumer函数式接口，它接受一个Param类型的参数，并可以调用Param对象上的方法来构建 AND 嵌套条件。condition：一个布尔值，用于控制是否应用这个 AND 嵌套逻辑。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.and(i -> i.and(j -> j.eq("name", "李白").eq("status", "alive"))
.and(j -> j.eq("name", "杜甫").eq("status", "alive")));
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.and(i -> i.and(j -> j.eq(User::getName, "李白").eq(User::getStatus, "alive"))
.and(j -> j.eq(User::getName, "杜甫").eq(User::getStatus, "alive")));
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE ((name = '李白' AND status = 'alive') AND (name = '杜甫' AND status = 'alive'))
注意事项
and方法的嵌套使用可以构建复杂的查询逻辑，其中 AND 条件可以包含多个查询条件。- 在使用
and方法的嵌套功能时，确保Consumer函数式接口中的逻辑正确构建了所需的查询条件。condition参数用于控制是否应用Consumer逻辑，这允许你根据某些条件动态添加查询条件。- 由于
and方法的嵌套使用可以执行复杂的逻辑，因此在使用时需要特别注意代码的可读性和维护性。
34. nested
nested 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于创建一个独立的查询条件块，不带默认的 AND 或 OR 逻辑。通过调用 nested 方法，可以在查询条件中添加一个嵌套的子句，该子句可以包含多个查询条件，并且可以被外部查询条件通过 AND 或 OR 连接。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 添加一个独立的查询条件块
nested(Consumer<Param> consumer)
nested(boolean condition, Consumer<Param> consumer)
参数说明
consumer：一个Consumer函数式接口，它接受一个Param类型的参数，并可以调用Param对象上的方法来构建嵌套的查询条件。condition：一个布尔值，用于控制是否应用这个嵌套逻辑。
示例
普通 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
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE (name = '李白' AND status <> '活着')
注意事项
nested方法创建的查询条件块是一个独立的子句，可以被外部查询条件通过 AND 或 OR 连接。- 在使用
nested方法时，确保Consumer函数式接口中的逻辑正确构建了所需的查询条件。condition参数用于控制是否应用Consumer逻辑，这允许你根据某些条件动态添加查询条件。- 由于
nested方法可以执行复杂的逻辑，因此在使用时需要特别注意代码的可读性和维护性。
35. apply
apply 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它允许你直接拼接 SQL 片段到查询条件中。这个方法特别适用于需要使用数据库函数或其他复杂 SQL 构造的场景。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 拼接 SQL 片段
apply(String applySql, Object... params)
apply(boolean condition, String applySql, Object... params)
参数说明
applySql：一个字符串，包含要拼接的 SQL 片段。params：一个可变参数列表，包含 SQL 片段中占位符的替换值。condition：一个布尔值，用于控制是否应用这个 SQL 片段。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.apply("id = 1");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.apply("id=1");
使用参数占位符的示例：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper1.apply("id= {0}", "1");
生成的 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'
注意事项
apply方法可用于拼接包含数据库函数的 SQL 片段。- 动态入参的
params对应applySql内部的{index}部分，这样是不会有 SQL 注入风险的。如果直接将参数拼接到 SQL 中，则会有 SQL 注入风险，故应避免 SQL 由前端动态参数传入并直接引用。- 在使用
apply方法时，确保 applySql 参数是一个有效的 SQL 片段，并且params参数正确地替换了占位符。condition参数用于控制是否应用这个 SQL 片段，这允许你根据某些条件动态添加查询条件。
36. last
last 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它允许你直接在查询的最后添加一个 SQL 片段，而不受 MyBatis-Plus 的查询优化规则影响。这个方法应该谨慎使用，因为它可能会绕过 MyBatis-Plus 的查询优化。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 在查询的最后添加一个 SQL 片段
last(String lastSql)
last(boolean condition, String lastSql)
参数说明
lastSql：一个字符串，包含要添加到查询最后的 SQL 片段。condition：一个布尔值，用于控制是否应用这个 SQL 片段。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.last("limit 1");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.last("limit 1");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user LIMIT 1
注意事项
last方法只能调用一次，多次调用将以最后一次为准。- 使用
last方法会绕过 MyBatis-Plus 的查询优化规则，可能会导致查询效率降低。- 因为
lastSql参数直接拼接到 SQL 中，所以必须确保输入的 SQL 片段是安全的，即保障lastSql应该是后端自行控制，而不是动态参数由前端传入。- 在使用
last方法时，确保 lastSql 参数是一个安全的 SQL 片段，并且condition参数正确地控制了 SQL 片段的应用。
37. exists
exists 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于在查询中添加一个 EXISTS 子查询。通过调用 exists 方法，可以将一个完整的 SQL 子查询作为 EXISTS 条件添加到主查询中。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 添加 EXISTS 子查询
exists(String existsSql)
exists(boolean condition, String existsSql)
参数说明
existsSql：一个字符串，包含要作为 EXISTS 条件的 SQL 子查询。condition：一个布尔值，用于控制是否应用这个 EXISTS 条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.exists("select id from user where age = 1");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.exists("select id from user where age = 1");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE EXISTS (select id from user where age = 1)
注意事项
exists方法用于添加一个 EXISTS 子查询，这通常用于检查子查询是否返回任何行。- 在使用
exists方法时，确保existsSql参数是一个有效的 SQL 子查询，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。condition参数用于控制是否应用 EXISTS 条件，这允许你根据某些条件动态添加查询条件。- 由于
exists方法允许执行复杂的逻辑，因此在使用时需要特别注意代码的可读性和维护性。
38. notExists
notExists 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于在查询中添加一个 NOT EXISTS 子查询。通过调用 notExists 方法，可以将一个完整的 SQL 子查询作为 NOT EXISTS 条件添加到主查询中。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 添加 NOT EXISTS 子查询
notExists(String notExistsSql)
notExists(boolean condition, String notExistsSql)
参数说明
notExistsSql：一个字符串，包含要作为 NOT EXISTS 条件的 SQL 子查询。condition：一个布尔值，用于控制是否应用这个 NOT EXISTS 条件。
示例
普通 Wrapper (QueryWrapper)：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notExists("select id from user where age = 1");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notExists("select id from user where age = 1");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE NOT EXISTS (select id from user where age = 1)
注意事项
notExists方法用于添加一个 NOT EXISTS 子查询，这通常用于检查子查询是否不返回任何行。- 在使用
notExists方法时，确保notExistsSql参数是一个有效的 SQL 子查询，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。condition参数用于控制是否应用 NOT EXISTS 条件，这允许你根据某些条件动态添加查询条件。- 由于
notExists方法允许执行复杂的逻辑，因此在使用时需要特别注意代码的可读性和维护性。
39. select
select 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询的字段。通过调用 select 方法，可以指定在查询结果中包含哪些字段，从而实现字段级别的查询定制。
使用范围
- QueryWrapper
- LambdaQueryWrapper
方法签名
// 设置查询字段
select(String... sqlSelect)
// 过滤查询字段（主键除外）
select(Predicate<TableFieldInfo> predicate)
select(Class<T> entityClass, Predicate<TableFieldInfo> predicate)
参数说明
sqlSelect：一个字符串数组，包含要查询的字段名。predicate：一个Predicate函数式接口，用于过滤查询字段。它接受一个TableFieldInfo类型的参数，并返回一个布尔值，表示是否选择该字段。entityClass：实体类的类型，用于获取字段信息。
示例
普通 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> queryWrapper1 = new QueryWrapper<>(User.class);
queryWrapper.select(i -> i.getProperty().startsWith("test"));
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT id, name, age FROM user
-- 使用 Predicate 过滤字段生成的 SQL
SELECT testField1, testField2 FROM user
注意事项
select方法分为两类：第一类直接指定要查询的字段名，第二类通过Predicate过滤字段。- 第二类方法用于过滤查询字段（主键除外），如果入参不包含
entityClass，则在调用前需要确保wrapper内的entity 属性有值。- 这两类方法重复调用时，以最后一次调用为准。
- 在使用
select方法时，确保指定的字段名或过滤条件正确，以避免查询结果不符合预期。
40. set
set 方法是 MyBatis-Plus 中用于构建更新操作的高级方法之一，它用于设置更新语句中的 SET 字段。通过调用 set 方法，可以指定在更新操作中要修改的字段及其新值。
使用范围
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置更新语句中的 SET 字段
set(String column, Object val)
set(boolean condition, String column, Object val)
参数说明
column：一个字符串，表示要更新的字段名。val：一个对象，表示要更新到字段的新值。condition：一个布尔值，用于控制是否应用这个 SET 字段。
示例
普通 Wrapper (QueryWrapper)：
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.set("name", "老李头");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.set(User::getName, "老李头");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
UPDATE user SET name = '老李头'
使用条件控制的示例：
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.set(true, "name", "");
生成的 SQL
-- 使用条件控制的 SQL
UPDATE user SET name = ''
注意事项
set方法用于设置更新语句中的 SET 字段，可以指定要更新的字段及其新值。- 当
val参数为空字符串时，数据库字段值将变为空字符串。- 当
val参数为null时，数据库字段值将变为null。condition参数用于控制是否应用这个 SET 字段，这允许你根据某些条件动态添加更新字段。- 在使用
set方法时，确保column参数是一个有效的字段名，并且val参数是一个合适的新值。
41. setSql
setSql 方法是 MyBatis-Plus 中用于构建更新操作的高级方法之一，它允许你直接设置更新语句中的 SET 部分 SQL。通过调用 setSql 方法，可以将一个自定义的 SQL 片段作为 SET 子句添加到更新语句中。
使用范围
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置更新语句中的 SET 部分 SQL
setSql(String sql)
参数说明
sql：一个字符串，包含要作为 SET 子句的 SQL 片段。
示例
普通 Wrapper (QueryWrapper)：
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.setSql("name = '老李头'");
Lambda Wrapper (LambdaQueryWrapper)：
LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.setSql("name = '老李头'");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
UPDATE user SET name = '老李头'
注意事项
setSql方法用于设置更新语句中的 SET 部分 SQL，这通常用于需要使用复杂 SQL 构造的场景。- 在使用
setSql方法时，确保sql参数是一个有效的 SQL 片段，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用- 由于
setSql方法允许执行复杂的逻辑，因此在使用时需要特别注意代码的可读性和维护性。
42. setIncrBy Since 3.5.6
setIncrBy 方法是 MyBatis-Plus 中用于更新操作的高级方法之一，它允许你指定一个字段，并使其在数据库中的值增加指定的数值。这个方法特别适用于需要对数值字段进行增量操作的场景。
使用范围
- LambdaUpdateWrapper
方法签名
// 字段自增指定数值
setIncrBy(SFunction<T, ?> column, Number val)
// 在条件满足时字段自增指定数值
setIncrBy(boolean condition, SFunction<T, ?> column, Number val)
参数说明
column：一个SFunction对象，表示要自增的字段。val：一个Number对象，表示要增加的数值。condition（可选）：一个布尔值，表示是否在满足条件时执行自增操作。
示例
Lambda Wrapper (LambdaQueryWrapper)：
LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.setIncrBy(User::getAge, 1);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
UPDATE product SET num = num + 1
注意事项
setIncrBy方法用于对指定字段进行自增操作，这通常用于需要对数值字段进行增量更新的场景。- 在使用
setIncrBy方法时，确保column参数是一个有效的字段表达式，val参数是一个有效的数值。- 如果提供了
condition参数，则只有在条件为true时才会执行自增操作。
43. setDecrBy
setDecrBy 方法是 MyBatis-Plus 中用于更新操作的高级方法之一，它允许你指定一个字段，并使其在数据库中的值减少指定的数值。这个方法特别适用于需要对数值字段进行减量操作的场景。
使用范围
- LambdaUpdateWrapper
方法签名
// 字段自减指定数值
setDecrBy(SFunction<T, ?> column, Number val)
// 在条件满足时字段自减指定数值
setDecrBy(boolean condition, SFunction<T, ?> column, Number val)
参数说明
column：一个SFunction对象，表示要自减的字段。val：一个Number对象，表示要减少的数值。condition（可选）：一个布尔值，表示是否在满足条件时执行自减操作。
示例
Lambda Wrapper (LambdaQueryWrapper)：
LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.setDecrBy(User::getAge, 1);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
UPDATE product SET num = num - 1
注意事项
setDecrBy方法用于对指定字段进行自减操作，这通常用于需要对数值字段进行减量更新的场景。- 在使用
setDecrBy方法时，确保column参数是一个有效的字段表达式，val参数是一个有效的数值。- 如果提供了
condition参数，则只有在条件为true时才会执行自减操作。
44. lambda
lambda 方法是一个便捷的方法，它允许你从 QueryWrapper 或 UpdateWrapper 对象中获取对应的 LambdaQueryWrapper 或 LambdaUpdateWrapper 对象。这样，你就可以使用 Lambda 表达式来构建查询或更新条件，使得代码更加简洁和类型安全。
使用范围
- QueryWrapper
- UpdateWrapper
方法签名
// 获取 Lamdba Wrapper
lambda();
示例
从 QueryWrapper 获取 LambdaQueryWrapper：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
LambdaQueryWrapper<User> lambdaQueryWrapper = queryWrapper.lambda();
// 使用 Lambda 表达式构建查询条件
lambdaQueryWrapper.eq(User::getName, "张三");
从 UpdateWrapper 获取 LambdaUpdateWrapper：
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
LambdaUpdateWrapper<User> lambdaUpdateWrapper = updateWrapper.lambda();
// 使用 Lambda 表达式构建更新条件
lambdaUpdateWrapper.set(User::getName, "李四");
说明
lambda方法返回一个LambdaWrapper对象，具体类型取决于调用它的Wrapper类型。- 在
QueryWrapper上调用lambda方法将返回一个LambdaQueryWrapper。 - 在
UpdateWrapper上调用 lambda方法将返回一个LambdaUpdateWrapper。 - 使用
Lambda表达式可以避免直接使用字符串来指定字段名，从而减少错误并提高代码的可读性。
注意事项
- 在使用
lambda方法时，确保你已经正确地初始化了QueryWrapper或UpdateWrapper对象。- 一旦获取了
LambdaWrapper对象，你就可以使用Lambda表达式来构建查询或更新条件，这将使得代码更加类型安全和易于维护。
总结
大家不要看内容很多就学不下去了,其实很多都是相关联的,你会了一个,再看其他的可能看一眼就明白它的作用了;
比如说：like、notLike、likeLeft、likeRight、notLikeLeft、notLikeRight,这一系列的api都是模糊匹配衍生出来的,用法基本相似,你能用到的场景Mybatis-Plus团队都帮你考虑到了。
种一棵树,最好的时间是十年前,其次,就是当下。
8261
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
